Türkçe makine öğrenmesi platformu

Makine öğrenmesini yazarak öğren

Makine öğrenmesini, LLM'leri, ajan sistemlerini ve GPU programlamayı Python'da kodlayarak ve pratik yaparak öğren. Hepsi Türkçe.

Ücretsiz hesap aç Derslere göz at

Hesabınla kodunu çalıştırır, çözümleri görür, ilerlemeni her cihazda sürdürürsün.

ML Temelleri'ne devam et Tüm yollar

gradient_descent

Kayıp eğrisi · loss curve

adım 0 / 12 · w = 4,000 · kayıp = 16,000

Öğrenme yolları

Yolunu seç, kodlayarak ilerle

Her yol kısa derslerden ve kodlama problemlerinden oluşur. İlk yol açık; diğerleri sırayla geliyor.

ML Temelleri
açık
gradyan inişi (gradient descent) · kayıp fonksiyonları · sinir ağları · geri yayılım (backprop) · normalizasyon
LLM İç Yapısı
yakında
tokenizasyon (BPE) · embedding · dikkat (attention) · transformer · RoPE · LoRA · RLHF, DPO · MoE · RAG
Sıfırdan bir LLM yaz
yakında
Yolları birleştiren proje: tokenizer'dan eğitime, KV cache'ten Triton çekirdeğine kendi küçük GPT'ni eğit.

Tüm yollar →

LLM'in iç yüzü

Bir dil modeli bir cümleyi nasıl işler?

Metin önce parçalara (tokens) bölünür. Model her adımda bir sonraki parçayı tahmin eder ve önceki hesapları önbellekte (KV cache) tutar.

Tokenizasyon BPE

Sık görülen harf çiftleri birleşir; Türkçe ekler kendi token'larına ayrılır.

birleşme 0 / 26 · token sayısı 36

Token token üretim NEXT TOKEN

$P(x_t \mid x_{<t}) = \mathrm{softmax}(z_t)$

Tensorhane'de makine öğrenmesini▍

adım 0 / 3

Önbellek KV CACHE

$K_{1:t} = [\,K_{1:t-1} ;\ k_t\,]$

adım 0 / 6

Transformer'ın kalbi

Dikkati gör

Dikkat mekanizması (attention), bir kelimeyi anlamlandırırken cümlenin hangi kısımlarına bakılacağını hesaplar. Kodu çalıştır: önce skorlar (scores) bulunur, softmax onları ağırlıklara (weights) çevirir, oklar ağırlık kadar kalınlaşır. Sonra istediğin kelimeye tıkla.

attention.py

\mathrm{Attention}(Q,K,V) = \mathrm{softmax}\!\left(\frac{QK^{\top}}{\sqrt{d_k}}\right)V

Anlam ilişkilerine bakar: zamir «o», cümlede kimi kastettiğini bulur.

import numpy as npdef softmax(x):    e = np.exp(x - x.max(axis=-1, keepdims=True))    return e / e.sum(axis=-1, keepdims=True)def attention(Q, K, V):    d_k = Q.shape[-1]    scores = Q @ K.T / np.sqrt(d_k)    weights = softmax(scores)    return weights @ V

$\textstyle\sum_j A_{ij} = 1$ her satırda
$0 \le A_{ij} \le 1$ ağırlıklar olasılık

Makale okuma

Transformer'ı makalesinden öğren

Bilimsel makale (research paper) okumak da kodlayarak öğrenilir. Transformer'ı tanıtan Attention Is All You Need makalesinin mimari şeklini yeniden çizdik: her blok bir kod satırı, her formül bir test. Çalıştır: İngilizce bir cümle kodlayıcıdan (encoder) geçer, kod çözücü (decoder) Türkçesini token token yazar.

transformer.py

Makalenin mimari şekli · ENCODER–DECODER

Makale §3 Model mimarisi

\mathrm{Attention}(Q,K,V) = \mathrm{softmax}\!\left(\tfrac{QK^{\top}}{\sqrt{d_k}}\right)V

Solda kodlayıcı (encoder) kaynak cümleyi okur, sağda kod çözücü (decoder) çeviriyi token token yazar.

Makale §3 Model mimarisi

\mathrm{Attention}(Q,K,V) = \mathrm{softmax}\!\left(\tfrac{QK^{\top}}{\sqrt{d_k}}\right)V

Solda kodlayıcı (encoder) kaynak cümleyi okur, sağda kod çözücü (decoder) çeviriyi token token yazar.

Makale §3.1 Aynı yol, sıradaki token

y_t = \arg\max_{w} P(w \mid y_{\lt t},\, x)

Decoder her yeni token için aynı adımları izler. Kodlayıcının belleği bir kez hesaplanır ve her adımda yeniden kullanılır.

Sonuç · çeviri: «kedi uyuyor»

\text{the cat sleeps} \;\longrightarrow\; \text{kedi uyuyor}

GPT gibi dil modelleri bu mimarinin yalnızca sağ yarısını kullanır: çapraz dikkat olmadan, maskeli bir decoder yığını. Bir bloğa tıkla, makalenin o kısmını yeniden oku.

Makale §3.4 Girdi gömme (input embedding)

x_i = E[\text{token}_i]\,\sqrt{d_{\text{model}}}

Her token, d_model = 512 boyutlu bir vektöre dönüşür.

Makale §3.5 Konumsal kodlama (positional encoding)

PE_{(pos,\,2i)} = \sin\!\left(pos / 10000^{2i/d_{\text{model}}}\right)

Dikkat kelime sırasını bilmez; konum, farklı frekanslı sinüs dalgalarıyla eklenir.

Makale §3.2.2 Çok başlı öz-dikkat (multi-head self-attention)

\mathrm{MultiHead}(Q,K,V) = \mathrm{Concat}(\mathrm{head}_1, \dots, \mathrm{head}_h)\,W^O

Her kelime cümlenin tamamına bakar; h = 8 baş bunu paralel yapar. Tek bir başı yukarıda adım adım gördün.

Makale §3.3 İleri besleme ağı (feed-forward)

\mathrm{FFN}(x) = \max(0,\, xW_1 + b_1)\,W_2 + b_2

Her token'a ayrı ayrı aynı iki katmanlı ağ uygulanır (d_ff = 2048).

Makale §3.1 Artık bağlantı ve N katman

\mathrm{LayerNorm}(x + \mathrm{Sublayer}(x))

Her alt katman artık bağlantıyla (residual) sarılır; katman N = 6 kez tekrarlanır. Çıkan vektörler decoder'ın belleği (memory) olur.

Makale §3.1 Bir sağa kaydırılmış çıktılar (shifted right)

y = \mathrm{Embed}(\langle s \rangle, y_1, \dots, y_{t-1}) + PE

Decoder <s> ile başlar ve o ana kadar ürettiği token'ları girdi olarak alır.

Makale §3.2.3 Maskeli öz-dikkat (masked self-attention)

\mathrm{softmax}\!\left(\tfrac{QK^{\top}}{\sqrt{d_k}} + M\right)V, \quad M_{ij} = -\infty \;\; (j \gt i)

Bir token yalnızca kendine ve öncekilere bakabilir. Eğitimde tüm dizi aynı anda işlendiği için gelecek maskelenir.

<s>kediuyuyor<s>××kedi×uyuyor

Makale §3.2.3 Kodlayıcı-kod çözücü dikkati (cross-attention)

Q = y\,W^Q, \quad K = m\,W^K, \quad V = m\,W^V

Sorgu (Q) decoder'dan, anahtar ve değer (K, V) encoder belleğinden gelir: çeviri kaynak cümleye bakar.

the %8cat %83sleeps %9

Makale §3.3 İleri besleme ağı (feed-forward)

\mathrm{FFN}(x) = \max(0,\, xW_1 + b_1)\,W_2 + b_2

Kodlayıcıdakiyle aynı yapı, ayrı ağırlıklar.

Makale §3.4 Linear ve softmax

P(y_t \mid y_{\lt t},\, x) = \mathrm{softmax}(h_t W)

Son konumun vektörü, sözlükteki her token için bir olasılığa çevrilir.

Makale §6.1 Token seçimi

y_t = \arg\max_{w} P(w)

Burada en olası token seçilir (greedy); makale çeviride beam search kullanır. Seçilen token bir sonraki adımda decoder'a geri girer.

kaynak: the cat sleeps

def encoder_layer(x):    x = layer_norm(x + self_attention(x))    return layer_norm(x + feed_forward(x))def decoder_layer(y, memory):    y = layer_norm(y + masked_self_attention(y))    y = layer_norm(y + cross_attention(y, memory))    return layer_norm(y + feed_forward(y))def translate(src, N=6):    x = embed(src) + positional_encoding(src)    for _ in range(N):        x = encoder_layer(x)    out = ["<s>"]    while out[-1] != "</s>":        y = embed(out) + positional_encoding(out)        for _ in range(N):            y = decoder_layer(y, x)        probs = softmax(linear(y[-1]))        out.append(vocab[argmax(probs)])    return out[1:]

$(n,\, d_{\text{model}})$ katman boyutu korur
$A_{ij} = 0,\; j \gt i$ gelecek görünmez
$\mu = 0,\ \sigma = 1$ LayerNorm çıktısı

Ajan sistemleri

Bir ajan araçları nasıl kullanır?

Ajan (agent), bir döngü içinde araç çağıran bir dil modelidir: düşünür, bir araç çağırır, sonucu gözler ve yeterli bilgi olunca yanıtlar. Bu kalıbın adı ReAct (reason + act). Kodu çalıştır: model iki aracı gerçekten çağırarak soruyu yanıtlar.

agent.py

ReAct döngüsü · TOOL CALLING

görevGPT-2 small'ın ağırlıkları fp16'da ne kadar bellek tutar?
düşünceÖnce modelin parametre sayısını bulmalıyım.
araç çağrısısearch(query="GPT-2 small parametre sayısı")
gözlemGPT-2 small: 124M parametre, 12 katman, d_model = 768, 12 dikkat başı.
düşünce124M parametre var; fp16'da her biri 2 bayt. Toplamı GB olarak hesaplayayım.
araç çağrısıcalculate(expr="124e6 * 2 / 1e9")
gözlem0.248
düşünceGereken bilgi elimde, yanıtlayabilirim.
yanıtYaklaşık 0,248 GB: 124 milyon parametre × 2 bayt.

araçlar: search, calculate · en fazla 5 adım

TOOLS = {"search": search, "calculate": calculate}def run_agent(task, max_steps=5):    messages = [{"role": "user", "content": task}]    for step in range(max_steps):        reply = llm(messages, tools=TOOLS)        messages.append(reply)        if not reply.tool_calls:            return reply.content        for call in reply.tool_calls:            result = TOOLS[call.name](**call.args)            messages.append({"role": "tool", "content": result})    raise RuntimeError("adım sınırı aşıldı")

validate(call.args)her çağrı şemaya uyuyor
step < max_stepsdöngü kendiliğinden bitti
answer == f(observations)yanıt araç sonuçlarından hesaplandı

GPU programlama

Matris çarpımı GPU'da nasıl paralelleşir?

Matris çarpımı (matrix multiplication), derin öğrenmedeki hesabın büyük kısmıdır. GPU, çıktıyı karolara (tiles) böler; her karoyu bir blok (thread block) hesaplar ve bloklar akış çoklu işlemcilerinde (streaming multiprocessor, SM) aynı anda çalışır. Kod Triton'da, yani Python'da.

matmul.py

Çarpımların küpü · TILED MATMUL

C_{ij} = \sum_{k} A_{ik}\,B_{kj}

dalga 0/2 · k 0/2 · karo 0/4

import tritonimport triton.language as tl# Her blok, C'nin bir karosunu hesaplar (kare matrisler).@triton.jitdef matmul_kernel(A, B, C, K, BLOCK: tl.constexpr):    i, j = tl.program_id(0), tl.program_id(1)    rows = i * BLOCK + tl.arange(0, BLOCK)    cols = j * BLOCK + tl.arange(0, BLOCK)    acc = tl.zeros((BLOCK, BLOCK), dtype=tl.float32)    for k in range(0, K, BLOCK):        ks = k + tl.arange(0, BLOCK)        a = tl.load(A + rows[:, None] * K + ks[None, :])        b = tl.load(B + ks[:, None] * K + cols[None, :])        acc += tl.dot(a, b)    tl.store(C + rows[:, None] * K + cols[None, :], acc)grid = (K // BLOCK, K // BLOCK)  # 2 x 2 blokmatmul_kernel[grid](A, B, C, K=64, BLOCK=32)

$C \approx A\,B$ sonuç doğru
$(M/B)^2$ karonun her biri bir kez hesaplandı

Yazarak öğrenmeye başla

İlk yol ML Temelleri: kısa dersler, kodlama problemleri ve bir bitirme projesi.

Hesap aç ML Temelleri'ne başla