# Hugging Face Transformers 2026: NLP, Fine-Tuning ve Mulakat Sorulari

> Hugging Face Transformers v5 rehberi — API mimarisi, LoRA ile fine-tuning, NLP pipeline'lari ve 2026'da data science mulakatlarinda en sik sorulan sorular.

- Published: 2026-05-19
- Updated: 2026-05-19
- Author: Anthony Fillion-Maillet
- Tags: hugging-face, transformers, nlp, fine-tuning, deep-learning, data-science, interview
- Reading time: 10 min

---

Hugging Face Transformers, NLP, bilgisayarla gorme ve ses isleme alanlarinda transformer tabanli modellerle calismanin standart kutuphanesi haline geldi. [Transformers v5](https://huggingface.co/blog/transformers-v5) surumuyle birlikte ve Hub'da bir milyonun uzerinde model checkpoint'i mevcut oldugundan, bu ekosistemi bilmek 2026'da data science mulakatlarinda temel bir beklenti olarak karsimiza cikiyor.

> **Transformers v5 ile Gelen Degisiklikler**
>
> Transformers v5, TensorFlow ve Flax destegini kaldirarak PyTorch-first yaklasimina gecis yapti. Kutuphane artik surekli batching, cikarim icin paged attention ve multimodal modeller icin birlesmis bir processor nesnesi sunuyor. Fine-tuning is akislari Unsloth, TRL ve Axolotl gibi araclarla uyumlu kalmaya devam ediyor.

## Transformers v5 Mimarisi ve Temel API Degisiklikleri

V4'ten v5'e gecis, kutuphanenin olusturulmasindan bu yana en buyuk yapisal degisikligi temsil ediyor. Gunluk kurulum sayisi v4'un bes yillik omru boyunca 20.000'den 3 milyonun uzerine cikti ve kod tabaninin onemli bir kismi v5'in dogrudan ele aldigi teknik borc biriktirdi.

Uygulamaci acisindan en onemli uc degisiklik sunlardir:

1. **Yalnizca PyTorch backend'i** — TensorFlow ve Flax model uygulamalari kaldirildi. JAX uyumlulugu ortak kutuphaneler araciligiyla surdurulse de Transformers'taki tum model tanimlari artik yalnizca PyTorch'u hedefliyor.
2. **Birlesmis processor** — Multimodal modeller (goruntu-dil, ses-dil) daha once tokenizer'lar ve ozellik cikaricilarin geici kombinasyonlarini gerektiriyordu. Tek bir `processor` nesnesi artik tum on islemeyi ustleniyor.
3. **Yerlesik cikarim sunucusu** — `transformers serve` komutu, surekli batching ve paged attention ile OpenAI uyumlu bir API sunarak bircok durumda ayri sunucu altyapisi ihtiyacini ortadan kaldiriyor.

```python
# serve_model.py
# Start an OpenAI-compatible inference server from the command line
# transformers serve --model meta-llama/Llama-4-Scout-17B-16E-Instruct --compile

# Or use the Python API directly
from transformers import pipeline

# The pipeline API remains the fastest way to get predictions
classifier = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
results = classifier(["Transformers v5 simplifies everything.", "Legacy code migration is painful."])
print(results)
# [{'label': 'POSITIVE', 'score': 0.9998}, {'label': 'NEGATIVE', 'score': 0.9994}]
```

Pipeline API'si tokenizasyon, model yukleme ve son islemeyi tek bir fonksiyon cagrisi arkasinda gizliyor. Uretim is yukleri icin `transformers serve`, dogru batching ve esanli islem yetenekleriyle ayni kolayligi sagliyor.

## Hub'dan Onceden Egitilmis Modelleri Yukleme ve Kullanma

Hugging Face Hub bir milyonun uzerinde model checkpoint'i barindiriyor. Bunlardan herhangi birini yuklemek iki satir kod gerektirse de hangi modelin secilecegini ve nasil yapilandirilacagini bilmek, yeni baslayanlarla deneyimli uzmanlari birbirinden ayiriyor.

`AutoModel` siniflari, model karti meta verilerinden dogru mimariyi otomatik olarak tespit eder. Bu, ayni yukleme kodunun BERT, GPT, T5, Llama veya herhangi bir baska mimari icin calisacagi anlamina gelir:

```python
# load_model.py
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load tokenizer and model — architecture detected automatically
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=3)

# Tokenize input text with padding and truncation
inputs = tokenizer(
    "Hugging Face makes NLP accessible.",
    return_tensors="pt",     # Return PyTorch tensors
    padding=True,
    truncation=True,
    max_length=128
)

# Run inference with no gradient computation
with torch.no_grad():
    outputs = model(**inputs)
    predictions = torch.softmax(outputs.logits, dim=-1)
    print(f"Class probabilities: {predictions}")
```

`from_pretrained` metodu ilk cagriida model agirliklarini, yapilandirmayi ve tokenizer sozlugunu indirir, ardindan yerel olarak onbellege alir. Sonraki cagrilar ag istegi olmadan onbellekten yukleme yapar.

## LoRA ve Trainer API ile Fine-Tuning

Buyuk modellerin tam fine-tuning'i ciddi miktarda GPU bellegi gerektiriyor — 7 milyar parametreli bir model FP32'de yalnizca agirliklar icin yaklasik 28 GB'a ihtiyac duyuyor. [LoRA (Low-Rank Adaptation)](https://huggingface.co/docs/peft/main/en/conceptual_guides/lora), onceden egitilmis agirliklari dondurarak ve her katmana kucuk, egitilebilir matrisler enjekte ederek bellek gereksinimlerini %60-80 oraninda azaltiyor.

PEFT kutuphanesi, LoRA fine-tuning'ini basit bir surec haline getirmek icin dogrudan Transformers ile entegre calisiyor:

```python
# finetune_lora.py
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model, TaskType
from datasets import load_dataset

# Load base model and tokenizer
model_name = "Qwen/Qwen3-0.6B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto")

# Configure LoRA — only 0.5-2% of parameters become trainable
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,                   # Rank of the low-rank matrices
    lora_alpha=32,          # Scaling factor
    lora_dropout=0.05,      # Dropout for regularization
    target_modules=["q_proj", "v_proj"],  # Which attention layers to adapt
)

# Wrap the model with LoRA adapters
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 1,572,864 || all params: 631,000,000 || trainable%: 0.25

# Load and tokenize dataset
dataset = load_dataset("tatsu-lab/alpaca", split="train[:5000]")

def tokenize(example):
    return tokenizer(example["text"], truncation=True, max_length=512, padding="max_length")

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

# Configure training
training_args = TrainingArguments(
    output_dir="./lora-qwen",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,  # Effective batch size = 16
    learning_rate=2e-4,
    bf16=True,                      # Use bfloat16 mixed precision
    logging_steps=50,
    save_strategy="epoch",
)

# Train
trainer = Trainer(model=model, args=training_args, train_dataset=tokenized)
trainer.train()
```

LoRA adapterleri temel modelden ayri olarak kaydedilir (tipik olarak birkac GB'a karsilik 10-50 MB). Birden fazla adapter, temel agirliklari yeniden yuklemeden cikarim sirasinda degistirilebilir; bu da LoRA'yi tek bir dagitiimdan birden fazla uzmanlasmis modeli sunmak icin ozellikle faydali kiliyor.

## NLP Pipeline Olusturma: Tokenizasyondan Cikarima

Transformers'taki her NLP gorevi ayni uc adimli deseni izler: girdiyi tokenize et, modelden gecir ve ciktiyi coz. Bu akisi anlamak, hem uretim sistemlerinin hata ayiklamasi hem de transformer mimarisiyle ilgili mulakat sorularini yanitlamak icin esastir.

Tokenizasyon, ham metni modelin anlayabilecegi sayisal kimliklere donusturur. Farkli model aileleri farkli tokenizasyon stratejileri kullanir — BERT WordPiece, GPT modelleri BPE ve T5 SentencePiece kullanir:

```python
# tokenization_demo.py
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
text = "Transformers handle tokenization automatically."

# Step-by-step tokenization
tokens = tokenizer.tokenize(text)          # Split into subwords
print(f"Tokens: {tokens}")
# ['transformers', 'handle', 'token', '##ization', 'automatically', '.']

ids = tokenizer.convert_tokens_to_ids(tokens)  # Convert to numeric IDs
print(f"IDs: {ids}")
# [19081, 5765, 19204, 6032, 8073, 1012]

# The encode method does both steps plus adds special tokens
encoded = tokenizer.encode(text, add_special_tokens=True)
print(f"Encoded with special tokens: {encoded}")
# [101, 19081, 5765, 19204, 6032, 8073, 1012, 102]
# 101 = [CLS], 102 = [SEP]
```

`##ization` token'i alt-kelime tokenizasyonunu gostermektedir — nadir kelimeler bilinen alt-kelimelere bolunur, boylece model, on egitim sirasinda gormedigi kelime hazinesini karakter duzeyinde geri donuslere basvurmadan ele alabilir.

## Verimli Dagitim icin Kuantizasyon

Kuantizasyon, agirliklari 32-bit kayan noktadan daha dusuk hassasiyet formatlarina donusturerek model boyutunu ve cikarim gecikmesini azaltir. 2026'da en pratik yaklasim, 7 milyar parametreli bir modeli yaklasik 4 GB GPU bellegine sigdiran 4-bit kuantizasyon icin [bitsandbytes](https://huggingface.co/docs/bitsandbytes/main/en/index) kullanir:

```python
# quantize_model.py
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

# Configure 4-bit quantization
quant_config = BitsAndBytesConfig(
    load_in_4bit=True,                      # Use 4-bit precision
    bnb_4bit_compute_dtype=torch.bfloat16,  # Compute in bfloat16
    bnb_4bit_quant_type="nf4",              # NormalFloat4 quantization
    bnb_4bit_use_double_quant=True,         # Quantize the quantization constants
)

# Load quantized model — fits in ~4GB VRAM instead of ~14GB
model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-Instruct-v0.3",
    quantization_config=quant_config,
    device_map="auto",  # Automatically distribute across available GPUs
)

tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")

# Inference works identically to the non-quantized model
inputs = tokenizer("Explain quantization in one sentence:", return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=50)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

4-bit kuantizasyon tipik olarak standart benchmark'larda %1'den az kalite dususu yaratirken bellek kullanimini %75 azaltir. LoRA ile birlestirildiginde, normalde coklu GPU kurulumu gerektirecek modellerin tek bir tuketici GPU'sunda fine-tuning yapilmasini mumkun kilar — bu teknik [QLoRA](https://arxiv.org/abs/2305.14314) olarak bilinir.

## Yaygin Hugging Face Mulakat Sorulari ve Cevaplari

2026'da data science mulakatlari, teorik anlayisin yaninda pratik Transformers bilgisini de giderek daha fazla sorguluyor. Asagidaki sorular ML muhendisi ve veri bilimci pozisyonlari icin teknik degerlendirmelerde siklikla karsimiza cikiyor.

> **Mulakat Odak Alanlari**
>
> Mulakatcilar genellikle uc alani inceler: (1) mimari bilgisi — self-attention, konumsal kodlama, encoder - decoder; (2) pratik beceriler — fine-tuning, kuantizasyon, model secimi; (3) sistem tasarimi — sunuculuk, batching, bellek optimizasyonu.

**Self-attention nedir ve multi-head attention onu nasil genisletir?**

Self-attention, her token icin dizideki diger tum token'larla iliskisine dayali agirlikli bir temsil hesaplar. Her token icin model uc vektor uretir: query (Q), key (K) ve value (V). Iki token arasindaki dikkat skoru, birinin query'si ile digerinin key'inin nokta carpimina esittir; bu deger anahtar boyutunun karekokuyle olceklenir ve softmax'ten gecirilir. Cikti, value vektorlerinin agirlikli toplamidir.

Multi-head attention bu islemi farkli ogrenilmis projeksiyonlarla paralel olarak birden fazla kez yurutur. Her "bas" farkli iliskitiplerine dikkat etmeyi ogrenebilir — bir basta sozdizimsel yapi, digerinde esreferans, bir digerinde konumsal yakinlik. Ciktilar birlestirilir ve model boyutuna geri projekte edilir.

**Transformer'lar neden konumsal kodlamaya ihtiyac duyar?**

RNN'ler ve LSTM'lerden farkli olarak, transformer'lar tum token'lari sirali degil, es zamanli olarak isler. Konum bilgisi olmadan model, girdiyi siralama kavrami olmayan bir token torbasi olarak ele alir. Konumsal kodlamalar (sabit sinuzoidal fonksiyonlar veya ogrenilmis gomulumler) ilk dikkat katmanindan once token gomulumlerine eklenir. LLaMA ve Qwen gibi modern modeller, mutlak yerine goreli konumlari kodlayan ve egitim sirasinda gorulenlerden daha uzun dizilere daha iyi genelleme yapan Rotary Position Embeddings (RoPE) kullanir.

**LoRA ne zaman tam fine-tuning'e tercih edilmelidir?**

LoRA, GPU bellegi sinirli oldugunda, temel model buyuk oldugunda (7 milyar+ parametre) veya tek bir temel modelden birden fazla goreve ozgu adapterin sunulmasi gerektiginde daha iyi bir secimdir. Tam fine-tuning benchmark'larda marjinal olarak daha iyi sonuclar verir (tipik olarak %0,5-2 daha yuksek dogruluk) ancak 4-8 kat daha fazla bellek gerektirir ve her gorev icin tam bir model kopyasi olusturur. Pratikte LoRA, cogu alt gorev icin karsilastirabilir kalite elde ederken egitim suresi ve altyapi maliyetlerini onemli olcude azaltir.

**Encoder-only, decoder-only ve encoder-decoder modeller arasindaki fark nedir?**

| Mimari | Ornekler | En Iyi Kullanim | Dikkat Deseni |
|---|---|---|---|
| Encoder-only | BERT, RoBERTa, DeBERTa | Siniflandirma, NER, gomulumler | Cift yonlu (tum baglami gorur) |
| Decoder-only | GPT, LLaMA, Mistral, Qwen | Metin uretimi, sohbet, kod | Nedensel (yalnizca soldan saga) |
| Encoder-decoder | T5, BART, mBART | Ceviri, ozetleme | Encoder ve decoder arasi capraz dikkat |

Encoder-only modeller, cift yonlu dikkat her token'in diger tum token'lari gozlemlemesine izin verdigi icin anlama gorevlerinde one cikar. Decoder-only modeller, nedensel maskeleme dogal olarak birer birer token urettigi icin uretim gorevlerinde baskindir. Encoder-decoder modeller her iki yetenegi birlestirse de buyuk olcude daha basit mimarilerle karsilastirabilir sonuclar elde eden decoder-only modeller tarafindan yerinden edilmistir.

> **Yaygin Mulakat Hatasi**
>
> Adaylar genellikle model boyutunu yetenekle karistirir. Iyi fine-tuning yapilmis 3 milyar parametreli bir model, belirli gorevlerde genel amacli 70 milyar parametreli bir modeli siklikla geride birakir. Mulakatcilar, daha kucuk ve uzmanlasmis modellerin ne zaman daha iyi bir muhendislik karari oldugunu anlayan adaylar arar.

**Trainer API dagitik egitimi nasil yonetir?**

`Trainer` sinifi mevcut GPU'lari otomatik olarak algilar ve veri paralelligini yapilandirir. Coklu dugum egitimi icin PyTorch'un `DistributedDataParallel` sistemiyle entegre olur ve tek bir yapilandirma dosyasi araciligiyla DeepSpeed ZeRO asamalari 1-3'u destekler. `TrainingArguments`'ta `deepspeed="ds_config.json"` ayarlamak, optimizer durumlarini, gradyanlari ve model parametrelerini GPU'lar arasinda paylastiran ve isteğe bagli olarak CPU RAM'e aktaran ZeRO-3 offloading'i etkinlestirmek icin yeterlidir.

**Bir NLP modelini degerlendirirken hangi metrikler onemlidir?**

Secim goreve baglidir. Siniflandirma icin: accuracy, F1-skoru (ozellikle dengesiz siniflar icin macro-F1), precision ve recall. Uretim icin: [BLEU](https://en.wikipedia.org/wiki/BLEU), ROUGE ve giderek daha fazla insan yargilamasiyla daha iyi korelasyon gosteren [BERTScore](https://github.com/Tiiiger/bert_score). Arama ve gomulumler icin: recall@k, NDCG ve mean reciprocal rank. Uretim sistemleri, kalite metriklerinin yaninda cikarim gecikmesi (p50/p99), verim (token/saniye) ve bellek kullanimini da izlemelidir.

## Hugging Face ve NLP Mulakatlarina Hazirlik

NLP odakli data science mulakatlarinda teknik hazirlik, tamamen teorik calismadan ziyade Transformers kutuphanesiyle uygulamali pratigten fayda gorur. En etkili yaklasim uc unsuru birlestirir:

- **Uctan uca projeler olusturma** — duygu siniflandirici, varlik adi tanima veya ozetleme pipeline'i. Her biri, mulakatcilarin dogrudan sorguladigi on isleme, model secimi ve degerlendirme konularinda kararlar almayi gerektirir.
- **Model kartlarini okuma** — Hub'daki model kartlari egitim verilerini, amaclanan kullanimi, sinirliliklari ve degerlendirme sonuclarini belgeler. Mulakatcilar, adaylarin en cok indirilen checkpoint'i koru korune secmek yerine model kartlarini elestirel olarak degerlendirmesini bekler.
- **Bellek ve gecikme profili cikarma** — farkli donanim yapilandirmalarinda FP32, FP16, BF16 ve INT4 cikarim arasindaki dengelemeleri anlamak, kidemli adaylari juniorlardan ayirir.

[SharpSkill NLP ve Hugging Face pratik modulu](/technologies/data-science/interview-questions/nlp-huggingface) bu konulari ayrintili aciklamalarla hedefli mulakat sorulari araciligiyla kapsiyor. [Transformer dikkat mekanizmalari](/technologies/data-science/interview-questions/transformers-attention) ve [derin ogrenme temelleri](/technologies/data-science/interview-questions/deep-learning-fundamentals) konularinda daha genis hazirlik icin data science yolu yapilandirilmis pratik planlari sunuyor.

## Sonuc

- Transformers v5, kutupaneyi PyTorch etrafinda birlestirir, eski backend'leri kaldirir ve uretim cikarimi icin `transformers serve` ile yerlesik sunuculuk sunar.
- `AutoModel` ve pipeline API'leri sifirdan calisan tahminlere giden en hizli yol olmaya devam ediyor — iki satir kod Hub'daki 1 milyondan fazla modelden herhangi birini yukler.
- PEFT araciligiyla LoRA fine-tuning, cogu gorev icin tam fine-tuning kalitesinin %1-2 sinirlarinda kalirken GPU bellek gereksinimlerini %60-80 oraninda azaltir.
- bitsandbytes ile 4-bit kuantizasyon, 7 milyar parametreli modelleri 4 GB VRAM'e sigdirir ve QLoRA her iki teknigi birlestirerek tuketici GPU'sunda fine-tuning'i mumkun kilar.
- Mulakat sorulari uc alana odaklanir: mimari bilgisi (self-attention, konumsal kodlama, encoder - decoder), pratik beceriler (fine-tuning, kuantizasyon, model secimi) ve sistem tasarimi (dagitik egitim, sunuculuk, bellek optimizasyonu).
- Tokenizasyon ic yapisini (WordPiece, BPE, SentencePiece) anlamak ve tokenizer davranisinin hatasini ayiklayabilmek, mulakatlarda siklıkla hafife alinan bir farklilastirici unsurdur.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/tr/blog/data-science/hugging-face-transformers-nlp-fine-tuning-interview-2026