``

LLM aslında ne yapar?

Büyük Dil Modelleri, metni insanlar gibi “anlamaya” çalışmaktan önce sıradaki parçayı tahmin eder. Metin, token adı verilen kelime, hece veya karakter parçalarına ayrılır. Model, önceki token’ları kullanarak bir sonraki token’ın olasılık dağılımını hesaplar:

Örneğin “Bugün hava çok” ifadesinden sonra “güzel” token’ına yüksek olasılık verilebilir. Bu işlem art arda tekrarlandığında paragraflar, kodlar ve hatta şiirler ortaya çıkar. Yani sihirli görünen sohbet, temelde olağanüstü gelişmiş bir otomatik tamamlama sürecidir.

Modelin parametreleri, sinir ağındaki öğrenilebilir sayısal ağırlıklardır. Eğitim sırasında tahmin ile gerçek token arasındaki hata ölçülür. Yaygın kayıp fonksiyonu kabaca şöyledir:

Geri yayılım ve gradyan inişi, bu kaybı azaltacak biçimde milyarlarca ağırlığı günceller. Transformer mimarisindeki attention mekanizması ise cümlenin hangi parçalarının birbirleriyle ilişkili olduğunu belirler. Böylece model, uzak kelimeler arasındaki bağlantıları yakalayabilir.

Ön eğitim, ince ayar ve RAG farkı

Her problemi modele yeniden ezberletmek gerekmez. İhtiyaca göre farklı uyarlama yöntemleri kullanılabilir:

Fine-tuning sürecinde kaliteli giriş-çıkış örnekleri hazırlanır. Ardından düşük öğrenme oranıyla eğitim yapılır ve model daha önce görmediği doğrulama verisiyle sınanır. Veri azsa LoRA gibi parametre-verimli yöntemler tercih edilebilir. LoRA, dev modelin tamamını değiştirmek yerine küçük ek matrisler öğrenerek maliyeti düşürür.

İyi bir istem nasıl yazılır?

“Bana yazılımı anlat” istemi belirsizdir. Model hedef kitleyi, kapsamı ve çıktı biçimini tahmin etmek zorunda kalır. Sağlam bir istem genellikle dört bileşen içerir:

1. Rol: Modelin hangi uzman gibi davranacağı.
2. Görev: Tam olarak ne üretileceği.
3. Bağlam: Kullanılacak bilgi ve sınırlamalar.
4. Çıktı biçimi: Tablo, JSON, liste veya kod gibi format.

Örneğin API üzerinden yapılandırılmış bir istem şöyle hazırlanabilir:

prompt = """
Rolün: Kıdemli Python geliştiricisi.
Görev: Aşağıdaki fonksiyondaki performans sorunlarını bul.
Kısıtlar: Davranışı değiştirme, en fazla üç öneri sun.
Çıktı: Sorun, neden ve düzeltilmiş kod başlıklarını kullan.
Kod:
{code}
"""

response = client.responses.create(
    model="uygun-model",
    input=prompt.format(code=source_code)
)

Bu kod, modele yalnızca soru sormaz; rol, sınır ve beklenen yapıyı da bildirir. Üretim ortamında kullanıcı verisi doğrudan isteme ekleniyorsa prompt injection saldırılarına karşı doğrulama ve yetkilendirme uygulanmalıdır.

Daha güvenilir sonuçlar için küçük taktikler

Karmaşık işleri tek seferde istemek yerine görevi aşamalara bölmek başarıyı artırır. Birkaç kaliteli örnek vermek few-shot prompting, hiç örnek vermeden açık talimat kullanmak ise zero-shot prompting olarak adlandırılır. Modelden bilinmeyen noktaları belirtmesini, varsayımlarını listelemesini ve mümkünse kaynak göstermesini istemek de halüsinasyon riskini azaltır.

Sonuç olarak LLM, niyet okuyan bir kahin değil; bağlamdan olasılık üreten güçlü bir sistemdir. Fine-tuning davranışı uzmanlaştırır, RAG güncel bilgiyi taşır, iyi prompting ise tüm bu kapasitenin doğru kapıya yönelmesini sağlar. Yapay zekâ çağında yalnızca cevabı bilmek değil, doğru soruyu tasarlamak da temel bir mühendislik becerisidir.

``

Görüntü bilgisayara nasıl görünür?

Gri tonlamalı bir görüntü $H \times W$ boyutlu bir matris, renkli görüntü ise genellikle $H \times W \times 3$ boyutlu bir tensördür. Son boyuttaki üç kanal kırmızı, yeşil ve maviyi temsil eder. Klasik tam bağlı ağlarda her piksel her nörona bağlanır; bu yaklaşım büyük görüntülerde devasa sayıda parametre üretir ve pikseller arasındaki komşuluk ilişkisini göz ardı eder.

CNN ise küçük bir filtreyi görüntü üzerinde gezdirir. Böylece hem daha az parametre kullanır hem de aynı özelliği görüntünün farklı bölgelerinde arayabilir. Bir kedinin kulağı sağda da olsa solda da olsa aynı filtre tarafından yakalanabilir.

Evrişim: Görüntü üzerinde gezinen büyüteç

Evrişim katmanındaki filtre, örneğin $3 \times 3$ boyutunda öğrenilebilir bir ağırlık matrisidir. Filtre her konumda görüntünün ilgili bölgesiyle eleman bazında çarpılır ve sonuçlar toplanır:

Burada $X$ giriş görüntüsünü, $K$ filtreyi, $b$ bias değerini ve $Y$ üretilen özellik haritasını gösterir. İlk katmanlar çoğunlukla yatay veya dikey kenarları öğrenir. Daha derin katmanlar bu basit bilgileri birleştirerek köşe, doku, göz, tekerlek veya kanat gibi daha karmaşık örüntüler oluşturur.

Çıktı boyutu yaklaşık olarak şu formülle hesaplanır:

$N$ giriş boyutu, $K$ filtre boyutu, $P$ padding ve $S$ stride değeridir. Padding görüntünün kenarlarına boşluk eklerken stride filtrenin kaç piksel atlayacağını belirler.

Havuzlama: Önemli bilgiyi sıkıştırmak

Pooling katmanı öğrenilebilir filtre taşımaz. Belirli bir pencere içindeki değerleri özetler. Max pooling en büyük değeri seçerken average pooling ortalamayı alır. Örneğin $2 \times 2$ max pooling, dört değerden en güçlü aktivasyonu saklar. Böylece özellik haritası küçülür, hesaplama hızlanır ve küçük konum değişikliklerine karşı dayanıklılık artar.

PyTorch ile küçük bir CNN

Aşağıdaki model, renkli $32 \times 32$ görüntüleri on sınıftan birine ayırabilecek temel bir mimari kurar:

import torch.nn as nn

class MiniCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(16, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        self.classifier = nn.Linear(32 * 8 * 8, 10)

    def forward(self, x):
        x = self.features(x)
        x = x.flatten(1)
        return self.classifier(x)

İlk evrişim katmanı RGB görüntüden 16 özellik haritası çıkarır. ReLU negatif değerleri sıfırlayarak modele doğrusal olmayanlık kazandırır. İki havuzlama işlemi görüntüyü $32 \times 32$ boyutundan $8 \times 8$ boyutuna indirir. Son katman ise çıkarılan özellikleri sınıf puanlarına dönüştürür.

CNN’lerin asıl gücü hiyerarşik öğrenmedir: erken katmanlar kenarları, orta katmanlar dokuları ve parçaları, derin katmanlar ise bütün nesneleri temsil eder. Bu nedenle CNN’ler yüz tanıma, tıbbi görüntü analizi, otonom sürüş ve kalite kontrol gibi alanlarda dijital dünyanın keskin gözleri hâline gelmiştir.

``

Derin öğrenme neden “derin”?

Yapay sinir ağları, girdileri belirli ağırlıklarla işleyen yapay nöronlardan oluşur. Tek bir nöronun temel işlemi şöyle gösterilebilir:

Burada $x_i$ girdileri, $w_i$ öğrenilen ağırlıkları, $b$ ise bias değerini temsil eder. Sonuç genellikle ReLU gibi doğrusal olmayan bir aktivasyon fonksiyonundan geçirilir:

Bir ağın “derin” olması, giriş ile çıkış arasında birden fazla gizli katman bulunması anlamına gelir. Katman sayısı arttıkça model, özellikleri hiyerarşik biçimde birleştirebilir. Bir görüntü ağının ilk katmanları kenarları, sonraki katmanları dokuları, daha ilerideki katmanları ise göz, tekerlek veya yüz gibi soyut yapıları öğrenebilir.

Bu özellikler geliştirici tarafından elle yazılmaz. Eğitim sırasında tahmin hatası geriye yayılım ile katmanlara dağıtılır. Ağırlıklar, kayıp fonksiyonunu azaltacak yönde güncellenir:

Buradaki $L$ kayıp fonksiyonu, $\eta$ ise öğrenme oranıdır. Kısacası ağ, hatalarından ders çıkarır; ancak bunu kahve molası vermeden milyonlarca kez yapar.

GPU neden bu kadar önemli?

Derin ağların eğitimi çok sayıda matris çarpımı gerektirir. CPU az sayıda güçlü çekirdekle genel amaçlı işlemlerde başarılıdır. GPU ise binlerce daha küçük çekirdeği sayesinde aynı türden matematiksel işlemleri paralel çalıştırabilir.

GPU seçiminde yalnızca işlem hızı değil, VRAM kapasitesi de önemlidir. Model parametreleri, ara aktivasyonlar ve gradyanlar bellekte tutulur. Bellek yetmediğinde batch boyutu küçültülebilir, karma hassasiyet kullanılabilir veya model birkaç GPU’ya dağıtılabilir. Daha büyük GPU her zaman daha akıllı model demek değildir; bazen yalnızca elektrik faturasının daha atletik olması demektir.

PyTorch ile cihaz seçimi

Aşağıdaki örnek, varsa CUDA destekli GPU’yu seçer ve basit bir ağı ilgili cihaza taşır:

import torch
from torch import nn

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

model = nn.Sequential(
    nn.Linear(784, 256),
    nn.ReLU(),
    nn.Linear(256, 10)
).to(device)

sample = torch.randn(64, 784).to(device)
predictions = model(sample)
print(device, predictions.shape)

to(device) çağrısı hem modelin hem de verinin aynı donanıma taşınmasını sağlar. Aksi hâlde PyTorch, CPU ve GPU tensörlerini birlikte işleyemediği için hata üretir.

Avantajlar ve sınırlar

Derin öğrenme; görüntü tanıma, doğal dil işleme, ses analizi ve üretken yapay zekâda elle özellik çıkarma ihtiyacını azaltır. Büyük ve karmaşık verilerde klasik yöntemlerden daha yüksek başarı sağlayabilir. Ayrıca önceden eğitilmiş modeller, transfer öğrenme ile daha küçük veri kümelerine uyarlanabilir.

Buna karşılık derin mimariler çok veri, enerji, zaman ve dikkatli hiperparametre ayarı ister. Katman eklemek başarıyı otomatik olarak artırmaz; aşırı öğrenme, kaybolan gradyan ve yüksek gecikme gibi sorunlar doğabilir. En iyi yaklaşım, probleme yetecek kadar derin bir model seçmek ve donanım gücünü ölçüm sonuçlarına göre kullanmaktır.

``

GAN: Sahtekâr ile dedektifin oyunu

GAN, 2014 yılında Ian Goodfellow ve çalışma arkadaşları tarafından tanıtıldı. Yapı, iki sinir ağından oluşur:

• Üretici (Generator): Rastgele gürültüyü gerçekçi bir örneğe dönüştürmeye çalışır.
• Ayırt edici (Discriminator): Karşısındaki örneğin gerçek veriden mi yoksa üreticiden mi geldiğini tahmin eder.

Üreticiyi sahte tablo yapan bir ressama, ayırt ediciyi ise sanat uzmanına benzetebiliriz. Ressam geliştikçe uzman daha dikkatli olur; uzman geliştikçe ressam daha başarılı sahte eserler üretmek zorunda kalır.

Bu rekabetin klasik amaç fonksiyonu şöyledir:

Burada $G(z)$ üreticinin gürültüden oluşturduğu örneği, $D(x)$ ise bir örneğin gerçek olma olasılığını gösterir. İdeal dengede ayırt edici artık gerçeği sahteden ayıramaz ve her örnek için yaklaşık $0.5$ sonucu verir.

GAN eğitiminin sadeleştirilmiş PyTorch benzeri akışı şöyledir:

# Önce ayırt edici, gerçek ve sahte örnekleri tanımayı öğrenir.
noise = torch.randn(batch_size, latent_size)
fake_images = generator(noise)

d_loss = discriminator_loss(
    discriminator(real_images),
    discriminator(fake_images.detach())
)
d_loss.backward()
d_optimizer.step()

# Ardından üretici, ayırt ediciyi kandıracak şekilde güncellenir.
g_loss = generator_loss(discriminator(fake_images))
g_loss.backward()
g_optimizer.step()

detach() kullanımı önemlidir: Ayırt edici eğitilirken gradyanların üreticiye akmasını engeller. Sonraki aşamada ise üretici, ayırt edicinin geri bildiriminden doğrudan yararlanır.

Difüzyon: Gürültüden düzene yolculuk

Difüzyon modelleri farklı bir oyun oynar. Eğitim sırasında temiz veriye aşamalı olarak Gauss gürültüsü eklenir. İleri süreç yaklaşık olarak şu şekilde ifade edilir:

Burada $x_0$ temiz örnek, $x_t$ gürültülü örnek ve $\epsilon$ rastgele gürültüdür. Sinir ağı, belirli bir adımdaki gürültüyü tahmin etmeyi öğrenir. Üretim aşamasında tamamen rastgele bir görüntüden başlanır ve tahmin edilen gürültü defalarca çıkarılır. Bulanık lekeler önce şekillere, ardından ayrıntılı bir görsele dönüşür.

Basitleştirilmiş örnekleme döngüsü şöyledir:

# Üretim tamamen rastgele gürültüyle başlar.
x = torch.randn(image_shape)

for timestep in reversed(range(total_steps)):
    predicted_noise = model(x, timestep)
    x = scheduler.remove_noise(x, predicted_noise, timestep)

# x artık modelin ürettiği temiz örnektir.

Gerçek sistemlerde zaman adımı kodlamaları, U-Net mimarileri, dikkat mekanizmaları ve özel gürültü zamanlayıcıları kullanılır. Metin komutları da gömleme vektörlerine çevrilerek üretim sürecini yönlendirebilir.

GAN mı, difüzyon mu?

GAN’ler gerçek zamanlı yüz dönüştürme, görüntü iyileştirme ve hızlı sentez için hâlâ değerlidir. Difüzyon modelleri ise metinden görsel, ses ve video üretiminde öne çıkar. Kısacası GAN bir düello, difüzyon ise sabırlı bir restorasyon sürecidir. Hangisinin seçileceği; hız, kalite, donanım maliyeti ve üretim üzerindeki kontrol ihtiyacına bağlıdır.

Bilgisayar kelimeleri nasıl görür?

En temel yaklaşım, her kelimeyi sözlükteki konumuna göre temsil eden one-hot encoding yöntemidir. Örneğin sözlüğümüzde üç kelime varsa “kedi” şu şekilde gösterilebilir:

“köpek” ise:

Bu vektörler farklı kelimeleri ayırır ancak aralarındaki anlam ilişkisini taşımaz. Matematiksel olarak “kedi” ile “köpek”, “kedi” ile “uçak” kadar uzaktır. Ayrıca sözlük yüz binlerce kelime içeriyorsa vektörler gereksiz derecede büyük ve seyrek olur.

Word embeddings, her kelimeyi genellikle 50–300 boyutlu yoğun bir vektörle temsil eder. Eğitim sırasında benzer bağlamlarda kullanılan kelimeler vektör uzayında birbirine yaklaşır. Bu fikir, dağılımsal anlambilimin meşhur özetine dayanır: Bir kelimeyi, birlikte bulunduğu kelimelerden tanırsın.

Word2Vec: Komşuna bak, kelimeyi tanı

Word2Vec, kelimelerin yakın çevresinden yararlanır ve iki temel mimari sunar:

• CBOW, çevredeki kelimelerden merkezdeki kelimeyi tahmin eder.
• Skip-gram, merkez kelimeden çevredeki kelimeleri tahmin eder.

“Minik kedi koltukta uyudu” cümlesinde CBOW, “minik” ve “koltukta” kelimelerinden “kedi”yi bulmaya çalışabilir. Skip-gram ise “kedi” verildiğinde çevresindeki sözcükleri tahmin eder. Büyük veri kümelerinde Skip-gram, nadir kelimeleri öğrenmekte çoğu zaman daha başarılıdır.

İki vektörün anlamsal yakınlığı sıklıkla kosinüs benzerliğiyle ölçülür:

Sonuç 1’e yaklaştıkça yönler ve dolayısıyla anlamlar daha benzerdir. Ünlü vektör aritmetiği örneği de şöyledir:

GloVe: Büyük resmin istatistiği

GloVe, yalnızca yerel kelime pencerelerine odaklanmak yerine bütün metindeki ortak görülme sayılarını kullanır. Bir kelimenin başka kelimelerle kaç kez yan yana geldiğini içeren eş-oluşum matrisi oluşturulur. Model, bu küresel istatistikleri düşük boyutlu vektörlere sıkıştırır.

Python ile hazır vektörleri kullanmak

Aşağıdaki örnek, Gensim üzerinden hazır GloVe vektörlerini yükler ve “computer” kelimesine yakın sözcükleri getirir:

import gensim.downloader as api

# Önceden eğitilmiş 50 boyutlu GloVe modelini indirir.
model = api.load("glove-wiki-gigaword-50")

# Vektör uzayındaki en yakın kelimeleri listeler.
for word, score in model.most_similar("computer", topn=5):
    print(word, round(score, 3))

Model, “software” veya “computers” gibi sözcükleri yüksek benzerlik puanlarıyla döndürebilir. Ancak klasik Word2Vec ve GloVe modellerinde her kelimenin yalnızca tek vektörü vardır. Bu nedenle “yüz” kelimesinin insan yüzü ve sayı anlamları bağlama göre ayrılamaz. BERT gibi bağlamsal modeller bu sınırlamayı giderse de kelime gömmeler; arama, öneri sistemleri, duygu analizi ve metin sınıflandırma projelerinde hâlâ hızlı, öğretici ve güçlü bir başlangıç noktasıdır.

``

Temel fikir: Ajan, ortam ve ödül

Pekiştirmeli öğrenmede ajan, belirli bir durumda eylem seçer. Ortam bu eyleme karşılık yeni bir durum ve sayısal bir ödül üretir. Bu döngü, ajan başarılı bir strateji geliştirene kadar sürer.

Amaç, yalnızca anlık ödülü değil, gelecekte elde edilecek toplam ödülü büyütmektir. İndirgenmiş toplam getiri şu şekilde gösterilir:

Buradaki $\gamma$, $0 \leq \gamma < 1$ aralığındaki iskonto katsayısıdır. Küçük bir $\gamma$, ajanı kısa vadeli kazançlara yöneltir. Büyük bir değer ise gelecekteki ödülleri önemseyen, daha sabırlı bir ajan oluşturur.

Markov karar süreci

Birçok pekiştirmeli öğrenme problemi, Markov Karar Süreci ile modellenir ve $(S, A, P, R, \gamma)$ bileşenleriyle ifade edilir. $S$ durumları, $A$ eylemleri, $P$ geçiş olasılıklarını, $R$ ödülleri temsil eder. Markov varsayımına göre geleceği tahmin etmek için mevcut durum yeterlidir; ajanın bütün geçmişi yanında taşıması gerekmez.

Bir durumun değerini hesaplayan Bellman eşitliği, bugünkü ödülle gelecekteki olası değeri birleştirir:

Bu ifade ilk bakışta matematik canavarı gibi görünse de mesajı basittir: “Bir durumun değeri, şimdi kazanacağım ödül ile sonra ulaşacağım durumların değeridir.”

Keşif mi, sömürü mü?

Ajan sürekli bildiği en iyi eylemi seçerse daha iyi seçenekleri keşfedemeyebilir. Sürekli rastgele davranırsa da öğrendiklerinden yararlanamaz. Bu ikileme exploration-exploitation dengesi denir.

$\epsilon$-greedy yaklaşımında ajan, $\epsilon$ olasılıkla rastgele; diğer durumlarda en yüksek değere sahip eylemi seçer.

Q-Learning ile küçük bir uygulama

Q-Learning, ortam modelini önceden bilmeden durum-eylem değerlerini öğrenir. Güncelleme kuralı şöyledir:

Aşağıdaki Python kodu bu güncellemenin özünü gösterir:

import random

Q = {}
alpha, gamma, epsilon = 0.1, 0.95, 0.1

def value(state, action):
    return Q.get((state, action), 0.0)

def choose_action(state, actions):
    if random.random() < epsilon:
        return random.choice(actions)  # Keşif
    return max(actions, key=lambda a: value(state, a))  # Sömürü

def update(state, action, reward, next_state, next_actions):
    old_q = value(state, action)
    best_next = max(value(next_state, a) for a in next_actions)
    target = reward + gamma * best_next
    Q[(state, action)] = old_q + alpha * (target - old_q)

choose_action keşif-sömürü dengesini kurarken update, alınan ödülü ve gelecekteki en iyi tahmini kullanarak Q tablosunu düzeltir. Eğitim ilerledikçe yüksek Q değerlerine sahip eylemler ajanın policy’sini oluşturur.

Pekiştirmeli öğrenme robotik, oyun, trafik kontrolü ve kaynak yönetimi gibi alanlarda güçlüdür. Ancak ödül yanlış tasarlanırsa ajan hedefin ruhunu değil, puan kazanmanın açığını öğrenebilir. Kısacası iyi bir ajan yetiştirmek için yalnızca algoritma değil, doğru ödül tasarımı da gerekir; yoksa robotunuz odayı temizlemek yerine kiri halının altına süpürebilir!

Sıralı veri neden farklıdır?

Klasik ileri beslemeli ağlarda her girdi genellikle diğerlerinden bağımsız değerlendirilir. Oysa sıralı verilerde örneklerin konumu ve geliş sırası anlam taşır. “Kedi köpeği kovaladı” ile “Köpek kediyi kovaladı” aynı kelimeleri içerir; ancak sıra değişince anlam da değişir.

Bir RNN, mevcut girdiyi işlerken önceki adımdan gelen gizli durumu kullanır:

Burada $x_t$ mevcut girdiyi, $h_{t-1}$ geçmişten taşınan bilgiyi, $h_t$ ise güncellenmiş hafızayı temsil eder. Ağın çıktısı çoğunlukla şu şekilde hesaplanır:

Başka bir deyişle RNN, her adımda hem yeni veriyi okur hem de eski not defterine göz atar.

RNN neden her şeyi hatırlayamıyor?

RNN teoride uzun süreli ilişkileri öğrenebilir. Pratikte ise eğitim sırasında kullanılan geriye yayılım, zaman boyunca çok sayıda çarpma işlemi gerçekleştirir. Türevler sürekli küçük değerlerle çarpılırsa gradyan sıfıra yaklaşır; buna kaybolan gradyan denir. Büyük değerlerle çarpıldığında ise patlayan gradyan oluşabilir.

Sonuç olarak standart RNN, birkaç adım önceki bilgiyi başarıyla kullanırken yüzlerce adım önceki kritik bir ayrıntıyı unutabilir. Romanın ilk bölümündeki karakteri finalde hatırlamayan bir okur gibi davranır.

LSTM: Kapılarla yönetilen hafıza

Long Short-Term Memory, hücre durumu adı verilen daha kararlı bir bilgi yolu kullanır. Bilginin kaderini üç temel kapı belirler:

• Unutma kapısı: Eski bilginin ne kadarının silineceğine karar verir.
• Girdi kapısı: Yeni bilginin ne kadarının hafızaya yazılacağını seçer.
• Çıktı kapısı: Hafızanın hangi bölümünün dışarı aktarılacağını belirler.

Unutma kapısının basitleştirilmiş hesabı şöyledir:

$sigmoid$ sonucu 0 ile 1 arasındadır. Sıfıra yakın değer “unut”, bire yakın değer ise “sakla” anlamına gelir.

Keras ile küçük bir LSTM modeli

Aşağıdaki model, son 30 zaman adımını inceleyerek bir sonraki sayısal değeri tahmin eder. Borsa kapanış fiyatları veya sensör ölçümleri gibi verilerde kullanılabilir:

from tensorflow.keras import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout

model = Sequential([
    LSTM(64, input_shape=(30, 1), return_sequences=True),
    Dropout(0.2),
    LSTM(32),
    Dense(1)
])

model.compile(optimizer="adam", loss="mse")
model.fit(X_train, y_train, epochs=20, batch_size=32)

İlk LSTM katmanı bütün zaman adımlarına ait çıktıları ikinci LSTM katmanına aktarır. Dropout, nöronların bir bölümünü eğitim sırasında geçici olarak kapatarak ezberlemeyi azaltır. Son Dense katmanı tek bir tahmin üretir. Modelden önce verileri ölçeklendirmek ve örnekleri (örnek, zaman_adımı, özellik) biçimine getirmek gerekir.

Nerelerde kullanılır?

RNN ve LSTM; konuşma tanıma, metin üretimi, duygu analizi, hava tahmini, anomali tespiti ve finansal modelleme gibi alanlarda kullanılabilir. Bununla birlikte borsa tahmininde geçmiş fiyatların geleceği garanti etmediği unutulmamalıdır. Günümüzde Transformer mimarileri birçok dil görevinde öne çıksa da LSTM, daha küçük veri kümeleri ve düşük kaynaklı zaman serisi projeleri için hâlâ güçlü, anlaşılır ve pratik bir seçenektir.

``

Akustik modem nasıl çalışır?

Dijital sistemde bitler yalnızca 0 ve 1’dir. Hoparlör ise doğrudan bit çalamaz; zamana göre değişen bir elektrik sinyalini sese dönüştürür. Bu nedenle bitleri ölçülebilir ses özellikleriyle temsil etmemiz gerekir.

İkili FSK, yani BFSK, iki farklı frekans kullanır:

• 0 biti için $f_0=1200\,Hz$
• 1 biti için $f_1=2200\,Hz$

Bir bitin süresi $T_b$ ise üretilen sinyal şöyle tanımlanabilir:

Burada $A$ genlik, $f_b$ ise bitin değerine göre seçilen frekanstır. Bit hızı yaklaşık olarak

bağıntısıyla bulunur. Örneğin her bit 20 milisaniye sürerse hız $50\,bit/s$ olur. Daha kısa semboller iletişimi hızlandırır; fakat yankı, gürültü ve zamanlama hatalarına karşı hassasiyeti artırır.

İlk proje için FSK iyi bir tercihtir; çünkü alıcının yalnızca iki frekanstan hangisinin daha güçlü olduğunu belirlemesi yeterlidir.

Verici tarafı

Aşağıdaki Python kodu metni bitlere çevirir, her bit için uygun sinüs dalgasını üretir ve sonucu WAV dosyasına kaydeder:

import numpy as np
from scipy.io.wavfile import write

SAMPLE_RATE = 44100
BIT_TIME = 0.02
FREQUENCIES = {'0': 1200, '1': 2200}

def text_to_bits(text):
    return ''.join(f'{byte:08b}' for byte in text.encode('utf-8'))

def make_tone(frequency):
    sample_count = int(SAMPLE_RATE * BIT_TIME)
    t = np.arange(sample_count) / SAMPLE_RATE
    return 0.5 * np.sin(2 * np.pi * frequency * t)

payload = text_to_bits('Merhaba modem!')
frame = '1010101010101010' + payload
signal = np.concatenate([make_tone(FREQUENCIES[b]) for b in frame])
write('mesaj.wav', SAMPLE_RATE, np.int16(signal * 32767))

Baştaki dönüşümlü bitler bir preamble oluşturur. Alıcı bu bilinen örüntüyü yakalayarak mesajın nerede başladığını ve sembol sınırlarını tahmin edebilir. Gerçek bir protokolde preamble sonrasında veri uzunluğu ve hata denetim alanı da bulunmalıdır.

Alıcı frekansı nasıl tanır?

Kaydı BIT_TIME uzunluğunda parçalara ayırıp her parçada 1200 Hz ile 2200 Hz enerjisini karşılaştırabiliriz. Bunun için FFT kullanılabilir. Yalnızca birkaç frekans aranıyorsa Goertzel algoritması daha hesaplıdır.

Bir frekansın ayrıştırılabilmesi örnekleme hızına bağlıdır. Nyquist koşuluna göre

olmalıdır. Burada $f_s=44100\,Hz$ olduğu için 2200 Hz rahatlıkla örneklenebilir.

import numpy as np

samples_per_bit = int(SAMPLE_RATE * BIT_TIME)

def energy_at(chunk, frequency):
    windowed = chunk * np.hanning(len(chunk))
    spectrum = np.fft.rfft(windowed)
    freqs = np.fft.rfftfreq(len(chunk), 1 / SAMPLE_RATE)
    index = np.argmin(np.abs(freqs - frequency))
    return abs(spectrum[index]) ** 2

def decode_chunk(chunk):
    low = energy_at(chunk, 1200)
    high = energy_at(chunk, 2200)
    return '1' if high > low else '0'

Hann penceresi, sembol sınırındaki ani kesilmelerin FFT üzerinde oluşturduğu spektral sızıntıyı azaltır. Çözülen bitler sekizli gruplara ayrılarak baytlara, ardından UTF-8 metne dönüştürülebilir.

Modemi daha güvenilir yapmak

Oda yankısı ve arka plan sesi kusursuz dalgaları küçük bir kaosa çevirebilir. Bu nedenle çerçeveye CRC-16 eklemek, her baytı birden fazla göndermek veya Hamming kodu kullanmak faydalıdır. Otomatik eşik belirleme, mikrofon kazancını dengeleme ve korelasyonla preamble arama da başarı oranını yükseltir.

Testleri önce WAV dosyaları arasında, sonra aynı odadaki hoparlör ve mikrofonla yapın. Ses düzeyini rahatsız etmeyecek seviyede tutun. Birkaç ıslık benzeri tonla başlayan bu proje; paketleme, hata düzeltme ve daha gelişmiş modülasyonlarla gerçek bir mini iletişim sistemine dönüşebilir.

``

Transformer’dan Önce Ne Vardı?

Doğal dil işlemede uzun süre RNN ve LSTM gibi tekrarlayan sinir ağları kullanıldı. Bu modeller metni sırayla işler: İkinci kelime için birincinin, üçüncü kelime için ilk ikisinin işlenmesini beklemek gerekir. Bu bağımlılık paralel hesaplamayı zorlaştırır ve uzun cümlelerin başındaki bilgilerin unutulmasına yol açabilir.

Transformer ise eğitim sırasında dizideki bütün konumları paralel olarak ele alır. Böylece hem modern GPU’lardan daha iyi yararlanır hem de birbirinden uzaktaki kelimeler arasında doğrudan bağlantı kurar. Ancak önemli bir ayrıntı var: GPT benzeri otoregresif modeller, metin üretirken sonraki token önceki tokenlara bağlı olduğu için çıkarım aşamasında hâlâ adım adım ilerler.

Attention’ın Üç Kahramanı: Query, Key ve Value

Self-attention mekanizmasında her token için üç vektör üretilir:

• Query (Q): Tokenın ne aradığını temsil eder.
• Key (K): Tokenın hangi bilgiyi sunduğunu belirtir.
• Value (V): Eşleşme gerçekleştiğinde aktarılacak bilgidir.

Bir query ile bütün key vektörlerinin benzerliği hesaplanır. Sonuçlar ölçeklenir, softmax ile olasılık benzeri ağırlıklara dönüştürülür ve value vektörleri bu ağırlıklarla birleştirilir:

Buradaki $d_k$, key vektörlerinin boyutudur. $\sqrt{d_k}$ ile bölme işlemi, büyük boyutlarda noktasal çarpımların aşırı büyümesini ve softmax fonksiyonunun dengesizleşmesini önler. Kısacası model, “Bu kelimeyi anlamak için diğer kelimelere ne kadar bakmalıyım?” sorusuna sayısal bir cevap verir.

Neden Birden Fazla Dikkat Başı Var?

Tek bir attention işlemi yalnızca belirli bir ilişki türüne odaklanabilir. Multi-head attention, farklı temsil uzaylarında birden fazla attention hesabını paralel yürütür. Bir baş özne-yüklem ilişkisini, başka biri zamirlerin referansını, diğeri ise anlamsal yakınlığı öğrenebilir.

Bu yapı, aynı cümleye farklı büyüteçlerle bakmak gibidir. Transformer katmanlarında attention sonrasında ileri beslemeli ağ, residual bağlantılar ve katman normalizasyonu da bulunur. Böylece bilgiler yalnızca seçilmez; dönüştürülür ve kararlı biçimde sonraki katmana aktarılır.

Kelime Sırası Nasıl Biliniyor?

Transformer kelimeleri aynı anda işlediği için sıra bilgisini kendiliğinden algılayamaz. Bu nedenle token temsillerine positional encoding eklenir. Klasik yaklaşım sinüs ve kosinüs fonksiyonlarını kullanır:

Böylece “köpek adamı ısırdı” ile “adam köpeği ısırdı” aynı kelimeleri içerse bile farklı anlamlara sahip olur.

Basitleştirilmiş Attention Kodu

Aşağıdaki PyTorch fonksiyonu, scaled dot-product attention hesabını gerçekleştirir:

import torch
import math

def attention(query, key, value, mask=None):
    d_k = query.size(-1)
    scores = query @ key.transpose(-2, -1)
    scores = scores / math.sqrt(d_k)

    if mask is not None:
        scores = scores.masked_fill(mask == 0, float("-inf"))

    weights = torch.softmax(scores, dim=-1)
    output = weights @ value
    return output, weights

mask, modelin dolgu tokenlarını görmesini veya gelecekteki kelimelere bakmasını engeller. Döndürülen weights ise hangi tokenın hangisine ne ölçüde dikkat ettiğini incelemeyi sağlar.

Güçlü Ama Bedelsiz Değil

Standart self-attention’ın zaman ve bellek maliyeti dizi uzunluğuna göre yaklaşık $O(n^2)$ seviyesindedir. Bu nedenle çok uzun belgeler pahalı olabilir. Sparse attention, FlashAttention ve pencere tabanlı yaklaşımlar bu yükü azaltmayı hedefler.

Yine de Transformer; çeviri, metin üretimi, görüntü işleme ve protein analizi gibi alanlarda ortak bir temel oluşturdu. Devrimin özü basit ama güçlüdür: Her kelimeyi tek başına değil, diğer bütün kelimelerle kurduğu ilişkiler üzerinden anlamlandırmak.

``

Algoritmik önyargı nereden gelir?

Bir modelin temel amacı, kayıp fonksiyonunu en aza indirmektir:

Ancak bu denklem neyin adil olduğunu kendiliğinden bilmez. Eğitim verisinde bir grup az temsil ediliyorsa model, toplam hatayı düşürürken o grubun hatasını önemsemeyebilir. Önyargı; veri toplama yönteminden, hatalı etiketlerden, seçilen özelliklerden veya sistemin kullanıldığı bağlamdan kaynaklanabilir.

Adalet denetiminde yalnızca genel doğruluk yeterli değildir. Örneğin iki grup için doğru pozitif oranları karşılaştırılabilir:

Fark büyüdükçe modelin gruplar arasında eşit fırsat sağlamadığı düşünülebilir. Yine de hiçbir adalet metriği evrensel değildir; demografik eşitlik, eşit fırsat ve hata oranı eşitliği bazı durumlarda birbiriyle çelişebilir.

Önyargıyı kodla denetlemek

Aşağıdaki Python örneği, iki grubun doğru pozitif oranlarını hesaplayarak basit bir denetim gerçekleştirir:

from sklearn.metrics import confusion_matrix

def true_positive_rate(y_true, y_pred):
    tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
    return tp / (tp + fn) if tp + fn else 0

for group in ["A", "B"]:
    mask = data["group"] == group
    rate = true_positive_rate(y_test[mask], predictions[mask])
    print(group, round(rate, 3))

Bu kod nihai bir adalet sertifikası vermez; yalnızca incelemeyi başlatır. Sonuçlar veri bilimciler, alan uzmanları, hukukçular ve etkilenen topluluklarla birlikte değerlendirilmelidir.

XAI: Model neden böyle karar verdi?

Açıklanabilir yapay zekâ, model davranışını insanlar için anlaşılır hâle getiren yöntemleri kapsar. SHAP, özelliklerin tahmine katkısını oyun teorisi yaklaşımıyla ölçerken LIME, belirli bir tahminin çevresinde daha basit bir yerel model kurar. Karar ağaçları doğrudan yorumlanabilir olabilir; derin ağlar ise çoğunlukla sonradan açıklama araçlarına ihtiyaç duyar.

Açıklama, kararın doğru veya adil olduğunu kanıtlamaz. Model ayrımcı bir kuralı gayet anlaşılır biçimde açıklayabilir! Bu nedenle XAI, adalet testleri ve insan gözetimiyle birlikte kullanılmalıdır.

Geleceğin risklerine karşı etik emniyet kemeri

Üretken modeller; yanlış bilgi, mahremiyet ihlali, siber saldırı desteği, manipülasyon ve kontrol kaybı gibi riskler doğurabilir. Çözüm, yalnızca modele “iyi davran” demek değildir. Riskli kullanım senaryoları önceden modellenmeli, kırmızı takım testleri yapılmalı, hassas veriler anonimleştirilmeli ve erişim yetkileri sınırlandırılmalıdır.

Kuruluşlar ayrıca veri ve model kartları yayımlamalı, olay bildirim mekanizmaları kurmalı, yüksek etkili kararlarda insan itiraz hakkını korumalıdır. Modeller dağıtımdan sonra performans, güvenlik ve grup bazlı hata açısından sürekli izlenmelidir. Etik yapay zekâ tek seferlik bir kontrol kutusu değil, modelin tüm yaşam döngüsüne yayılan bir mühendislik disiplinidir. Kısacası güçlü model yapmak önemlidir; fakat kimin için, hangi bedelle ve kimin denetiminde güçlü olduğunu sormak çok daha önemlidir.