Fine-tuning
& LoRA.

from transformers import (
    AutoModelForCausalLM, AutoTokenizer,
    TrainingArguments, Trainer,
    DataCollatorForLanguageModeling
)
from datasets import load_dataset
import torch

# Model ve tokenizer yükle
model_id = "meta-llama/Llama-3.2-3B"
tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,   # mixed precision
    device_map="auto",
)

# Gradient checkpointing aktif et → bellek tasarrufu
model.gradient_checkpointing_enable()
model.config.use_cache = False  # checkpointing ile uyumsuz

# Veri seti yükle ve tokenize et
dataset = load_dataset("your_dataset", split="train")

def tokenize(examples):
    return tokenizer(
        examples["text"],
        truncation=True,
        max_length=2048,
        padding=False,
    )

tokenized = dataset.map(tokenize, batched=True)

# TrainingArguments — full FT için tipik değerler
args = TrainingArguments(
    output_dir="./output",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,   # effective bs = 16
    learning_rate=2e-5,               # full FT için daha düşük
    bf16=True,
    logging_steps=10,
    save_strategy="epoch",
    warmup_ratio=0.03,
    lr_scheduler_type="cosine",
)

collator = DataCollatorForLanguageModeling(
    tokenizer, mlm=False
)

trainer = Trainer(
    model=model,
    args=args,
    train_dataset=tokenized,
    data_collator=collator,
)

trainer.train()

pip install peft transformers accelerate datasets trl

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import get_peft_model, LoraConfig, TaskType
import torch

model_id = "meta-llama/Llama-3.2-3B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"   # causal LM için sağ padding

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
model.config.use_cache = False

# LoRA konfigürasyonu
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules="all-linear",   # tüm lineer katmanlar
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM,
)

# Base modeli LoRA adaptörüyle sar
model = get_peft_model(model, lora_config)

# Eğitilecek parametre sayısını göster
model.print_trainable_parameters()
# → trainable params: 39,976,960 || all params: 3,252,793,344 || trainable%: 1.2291

# Sadece LoRA parametreleri requires_grad=True
for name, param in model.named_parameters():
    if "lora" in name:
        print(f"{name}: {param.shape}")
        break
# → base_model.model.model.layers.0.self_attn.q_proj.lora_A.weight: (16, 3072)

from transformers import (
    AutoModelForCausalLM, AutoTokenizer,
    BitsAndBytesConfig
)
from peft import get_peft_model, LoraConfig, prepare_model_for_kbit_training
import torch

model_id = "meta-llama/Llama-3.1-8B-Instruct"

# 4-bit quantization konfigürasyonu
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",          # Normal Float 4
    bnb_4bit_compute_dtype=torch.bfloat16, # hesaplama bf16
    bnb_4bit_use_double_quant=True,       # iç içe quantization
)

# Model 4-bit ile yükle
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto",
)

# 4-bit eğitim için hazırla (gradient checkpoint + cast)
model = prepare_model_for_kbit_training(model)

tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.pad_token = tokenizer.eos_token

# LoRA adaptörü ekle
lora_config = LoraConfig(
    r=64,
    lora_alpha=128,
    target_modules="all-linear",
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# → trainable params: 167,772,160 || all params: 8,197,615,616 || trainable%: 2.05

from transformers import (
    AutoModelForCausalLM, AutoTokenizer,
    BitsAndBytesConfig, TrainingArguments,
    EarlyStoppingCallback
)
from peft import LoraConfig, prepare_model_for_kbit_training
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset
import torch

# ── 1. Model yükleme (QLoRA) ──────────────────────────────
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.2-3B-Instruct",
    quantization_config=bnb_config,
    device_map="auto",
)
model = prepare_model_for_kbit_training(model)

tokenizer = AutoTokenizer.from_pretrained(
    "meta-llama/Llama-3.2-3B-Instruct"
)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

# ── 2. LoRA config ────────────────────────────────────────
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules="all-linear",
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

# ── 3. Veri seti ──────────────────────────────────────────
dataset = load_dataset("timdettmers/openassistant-guanaco")
train_data = dataset["train"]
eval_data  = dataset["test"]

# ── 4. SFTConfig (= TrainingArguments alt sınıfı) ─────────
sft_config = SFTConfig(
    output_dir="./llama3-sft",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    bf16=True,
    logging_steps=25,
    save_strategy="steps",
    save_steps=500,
    eval_strategy="steps",
    eval_steps=500,
    load_best_model_at_end=True,
    warmup_ratio=0.03,
    lr_scheduler_type="cosine",
    max_seq_length=2048,
    packing=True,           # kısa örnekleri birleştir
    report_to="wandb",       # Wandb logging
)

# ── 5. Trainer ────────────────────────────────────────────
trainer = SFTTrainer(
    model=model,
    args=sft_config,
    train_dataset=train_data,
    eval_dataset=eval_data,
    peft_config=lora_config,
    tokenizer=tokenizer,
    callbacks=[EarlyStoppingCallback(early_stopping_patience=3)],
)

trainer.train()
trainer.save_model("./llama3-sft-final")

# Alpaca formatı — instruction + input + output
alpaca_template = """Below is an instruction that describes a task, \
paired with an input that provides further context. \
Write a response that appropriately completes the request.

### Instruction:
{instruction}

### Input:
{input}

### Response:
{output}"""

# Input olmayan durum için
alpaca_no_input = """Below is an instruction that describes a task. \
Write a response that appropriately completes the request.

### Instruction:
{instruction}

### Response:
{output}"""

def formatting_func(example):
    if example["input"]:
        return alpaca_template.format(**example)
    return alpaca_no_input.format(**example)

# ChatML formatı — system + user + assistant rolleri
chatml_example = """<|im_start|>system
Sen yardımcı bir Türkçe asistansın.<|im_end|>
<|im_start|>user
Python'da bir liste nasıl sıralanır?<|im_end|>
<|im_start|>assistant
Python'da liste sıralamak için iki yol vardır:
1. list.sort() — in-place sıralar
2. sorted(list) — yeni liste döner<|im_end|>"""

# HuggingFace chat template API ile
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B-Instruct")

messages = [
    {"role": "system", "content": "Sen yardımcı bir asistansın."},
    {"role": "user",   "content": "Merhaba!"},
    {"role": "assistant", "content": "Merhaba! Nasıl yardımcı olabilirim?"},
]

formatted = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=False,
)
print(formatted)

from trl import DataCollatorForCompletionOnlyLM

# Llama 3 için assistant başlangıç token'ı
response_template = "<|start_header_id|>assistant<|end_header_id|>"

collator = DataCollatorForCompletionOnlyLM(
    response_template=response_template,
    tokenizer=tokenizer,
)

# SFTTrainer'a ver
trainer = SFTTrainer(
    ...,
    data_collator=collator,
    # packing=False olmalı completion-only ile
)

pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps "xformers<0.0.27" "trl<0.9.0" peft accelerate bitsandbytes

from unsloth import FastLanguageModel
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset
import torch

# ── 1. Model ve tokenizer — Unsloth API ──────────────────
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.2-3B-Instruct",
    max_seq_length=2048,
    dtype=None,          # otomatik tespit
    load_in_4bit=True,   # QLoRA modu
)

# ── 2. LoRA adaptörü — Unsloth'un get_peft_model'i ───────
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                     "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,          # Unsloth optimizasyonu için 0 önerilir
    bias="none",
    use_gradient_checkpointing="unsloth",  # özel implement
    random_state=3407,
)

# ── 3. Chat template formatı ──────────────────────────────
from unsloth.chat_templates import get_chat_template
tokenizer = get_chat_template(tokenizer, chat_template="llama-3")

def formatting_prompts_func(examples):
    convos = examples["conversations"]
    texts  = [tokenizer.apply_chat_template(c, tokenize=False,
              add_generation_prompt=False) for c in convos]
    return {"text": texts}

dataset = load_dataset("mlabonne/FineTome-100k", split="train")
dataset = dataset.map(formatting_prompts_func, batched=True)

# ── 4. Eğitim ─────────────────────────────────────────────
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    args=SFTConfig(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=5,
        max_steps=60,           # hızlı test için
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=1,
        optim="adamw_8bit",     # 8-bit Adam → daha az bellek
        seed=3407,
        output_dir="outputs",
    ),
)

trainer_stats = trainer.train()
print(f"Eğitim süresi: {trainer_stats.metrics['train_runtime']:.1f}s")

from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

base_model_id  = "meta-llama/Llama-3.2-3B-Instruct"
adapter_path   = "./llama3-sft-final"
merged_path    = "./llama3-sft-merged"

# ── 1. Base modeli yükle (fp16 — birleştirme için) ────────
base_model = AutoModelForCausalLM.from_pretrained(
    base_model_id,
    torch_dtype=torch.float16,
    device_map="auto",
)

# ── 2. Adaptörü yükle ─────────────────────────────────────
model = PeftModel.from_pretrained(base_model, adapter_path)

# ── 3. Birleştir ve PEFT sarmalını kaldır ─────────────────
model = model.merge_and_unload()
print("Birleştirme tamamlandı.")
print(type(model))  # → LlamaForCausalLM (PEFT yok)

# ── 4. Kaydet ─────────────────────────────────────────────
model.save_pretrained(merged_path, safe_serialization=True)

tokenizer = AutoTokenizer.from_pretrained(base_model_id)
tokenizer.save_pretrained(merged_path)
print(f"Model kaydedildi: {merged_path}")

# ── 5. HuggingFace Hub'a yükle (opsiyonel) ────────────────
from huggingface_hub import HfApi
api = HfApi()

# Önce login: huggingface-cli login
model.push_to_hub(
    "your-username/llama3-finetuned",
    safe_serialization=True,
    private=True,
)
tokenizer.push_to_hub("your-username/llama3-finetuned")

# Standart HuggingFace formatı
model.save_pretrained_merged(
    "model_merged",
    tokenizer,
    save_method="merged_16bit",
)

# GGUF formatı — llama.cpp / Ollama için
model.save_pretrained_gguf(
    "model_gguf",
    tokenizer,
    quantization_method="q4_k_m",  # 4-bit GGUF
)

# Hub'a yükle
model.push_to_hub_merged(
    "your-username/llama3-merged",
    tokenizer,
    save_method="merged_16bit",
    token="hf_...",
)