``

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.

Neden klasik yaklaşım yetmez?

En basit sunucular accept() ile bağlantı kabul eder, ardından read() çağrısıyla veri bekler. Ancak bu fonksiyonlar bloklayan kipte çalışırsa yavaş bir istemci tüm yürütme akışını durdurabilir. Her bağlantı için yeni bir thread açmak sorunu kısmen çözer; fakat binlerce thread bellek tüketir, zamanlayıcıyı yorar ve bağlam değiştirme maliyeti oluşturur.

Yaklaşık bellek tüketimini şöyle düşünebiliriz:

Burada $N$ bağlantı veya thread sayısını, $S$ ise her thread’in stack boyutunu temsil eder. 10.000 thread ve 1 MB stack kullanıldığında teorik ihtiyaç yaklaşık 10 GB olur. Olay döngüsünde ise az sayıda thread, binlerce soketi izleyebilir.

select her turda tüm dosya tanıtıcılarını tararken epoll_wait, yalnızca hazır olayları döndürür. Basitleştirilmiş maliyet karşılaştırması select için $O(N)$, hazır olay sayısı $K$ olan bir olay döngüsü için yaklaşık $O(K)$ şeklindedir.

Soketleri bloklamayan kipe almak

Linux soketini O_NONBLOCK bayrağıyla yapılandırırız. Böylece hemen tamamlanamayan accept, read veya write işlemleri programı uyutmak yerine EAGAIN hatası döndürür.

static int make_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) return -1;
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

Bu küçük yardımcı, hem dinleme soketine hem de kabul edilen istemci soketlerine uygulanmalıdır.

Epoll olay döngüsü

Dinleme soketi oluşturulup bind() ve listen() çağrıları tamamlandıktan sonra bir epoll örneği açılır:

int epfd = epoll_create1(0);

struct epoll_event ev = {
    .events = EPOLLIN,
    .data.fd = server_fd
};
epoll_ctl(epfd, EPOLL_CTL_ADD, server_fd, &ev);

for (;;) {
    struct epoll_event events[1024];
    int count = epoll_wait(epfd, events, 1024, -1);

    for (int i = 0; i < count; i++) {
        int fd = events[i].data.fd;

        if (fd == server_fd) {
            accept_clients(server_fd, epfd);
        } else if (events[i].events & EPOLLIN) {
            handle_request(fd, epfd);
        }
    }
}

accept_clients fonksiyonu tek bağlantı kabul edip dönmemelidir. Edge-triggered kullanımda accept() çağrısı EAGAIN verene kadar döngü sürmelidir. Aynı kural read() için de geçerlidir; aksi hâlde sokette veri kalmasına rağmen yeni bildirim alınmayabilir.

HTTP yanıtı ve kısmi yazmalar

Minimal bir yanıt şu biçimdedir:

const char *response =
    "HTTP/1.1 200 OK\r\n"
    "Content-Length: 13\r\n"
    "Connection: close\r\n"
    "\r\n"
    "Merhaba HTTP!";

Bloklamayan send() yanıtın yalnızca bir bölümünü yazabilir. Bu nedenle her bağlantı için tampon, gönderilen bayt sayısı ve ayrıştırma durumu tutulmalıdır. Yazma tamamlanamazsa soket EPOLLOUT olayına kaydedilir; tamamlanınca bu ilgi kaldırılır. Sürekli EPOLLOUT izlemek işlemciyi gereksiz yere meşgul eder.

Epoll ve kqueue farkı

Taşınabilirlik için olay kayıtlarını soyutlayan küçük bir arayüz yazılabilir. Güvenli bir gerçek dünya sunucusunda ayrıca zaman aşımı kuyruğu, maksimum istek boyutu, HTTP ayrıştırıcısı, TLS, sinyal yönetimi ve bağlantı başına geri basınç bulunmalıdır. Böylece oyuncak sunucu, internetin huysuz istemcilerine karşı dayanıklı bir altyapıya dönüşür.

Dilimizin temel modeli

Cebirsel veri tipi, mevcut tipleri toplam ve çarpım işlemleriyle birleştirir. Örneğin Bool, iki olası değerden oluştuğu için toplam tipidir:

Pair Int Bool ise iki değeri birlikte taşıdığı için çarpım tipidir:

Bu bakış açısı yalnızca matematiksel süs değildir. Derleyici, bir case ifadesinin tüm olasılıkları kapsayıp kapsamadığını bu yapı üzerinden inceleyebilir.

Soyut sözdizimi ağacı

Kaynak kodu doğrudan makine komutlarına çevirmek yerine önce bir AST oluştururuz. AST, boşluk ve parantez gibi ayrıntıları atarak programın anlamını saklar.

data Expr
  = LitInt Int
  | Var Name
  | Add Expr Expr
  | Con Name [Expr]
  | Case Expr [Branch]

data Pattern
  = PWildcard
  | PVar Name
  | PCon Name [Pattern]

data Branch = Branch Pattern Expr

Con veri kurucusu oluşturur; PCon ise aynı kurucuyu örüntü içinde arar. Örneğin Some 42, Con Some [LitInt 42] biçiminde temsil edilir. Bu ayrım önemlidir: ifade bir değer üretirken, örüntü mevcut değeri sorgular.

Örüntüleri derlemek

Sanal makinemizin yığın kullandığını varsayalım. Her cebirsel değer, kurucu etiketi ve alanlarından oluşsun. Some 7 kabaca (Some, [7]) şeklinde düşünülebilir.

data Instr
  = PushInt Int
  | Load Name
  | Build Name Int
  | TestTag Name Label
  | Unpack Int
  | Jump Label
  | Mark Label
  | FailMatch

Bir örüntüyü derleyen fonksiyon, başarısızlık durumunda gidilecek etiketi alır:

compilePattern :: Pattern -> Label -> [Instr]
compilePattern PWildcard _ = []
compilePattern (PVar name) _ = [Bind name]
compilePattern (PCon tag fields) fail =
  [TestTag tag fail, Unpack (length fields)]
  ++ concatMap (`compilePattern` fail) fields

Buradaki fikir kısa ama güçlüdür: TestTag, değerin kurucusunu kontrol eder; uyuşmazsa sonraki dala sıçrar. Unpack, kurucunun alanlarını yığına açar. Alt örüntüler daha sonra aynı yöntemle özyinelemeli olarak işlenir.

case ifadesinin kod üretimi

Her dal için bir sonraki dal etiketi ve ortak bir bitiş etiketi üretiriz:

compileCase scrutinee branches =
  compileExpr scrutinee ++ go branches
  where
    go [] = [FailMatch]
    go (Branch pat body : rest) =
      let next = freshLabel()
          done = caseEndLabel
      in  [Dup]
       ++ compilePattern pat next
       ++ [Pop]
       ++ compileExpr body
       ++ [Jump done, Mark next]
       ++ go rest

Dup, aynı değerin sonraki dalda tekrar denenebilmesini sağlar. Başarılı dal gövdesini çalıştırıp sona atlar; hiçbir dal eşleşmezse FailMatch devreye girer. Gerçek bir derleyicide etiket üretimi saf bir State monadıyla yönetilebilir.

Kaplayıcılık ve son dokunuşlar

Çalışma zamanındaki FailMatch yararlıdır, fakat hatayı derleme aşamasında bulmak daha iyidir. Maybe a üzerinde yalnızca Some x dalı varsa eksik kurucu kümesi şöyledir:

İlk sürümde yalnızca üst seviye kurucuları karşılaştırabilir, joker örüntüsü görüldüğünde kümeyi tamamen kapsanmış sayabiliriz. Sonraki adımlarda iç içe örüntüler, tip çıkarımı, gereksiz dal uyarıları ve kuyruk çağrısı optimizasyonu eklenebilir. Böylece küçük derleyicimiz, birkaç veri tanımından başlayıp fonksiyonel dillerin kalbindeki önemli fikirlere uzanan sevimli bir laboratuvara dönüşür.

Ham ivmeölçer verisini anlamak

İvmeölçer, telefonun üç eksendeki ivmesini ölçer: $a_x$, $a_y$ ve $a_z$. Değerler genellikle $m/s^2$ cinsindendir. Telefon masada hareketsiz olsa bile sensör sıfır göstermez; çünkü yerçekimi ivmesi olan yaklaşık $9.81\,m/s^2$ ölçüme dahildir.

Telefonun cebimizdeki yönü sürekli değişebileceği için eksenleri ayrı ayrı kullanmak kırılgan bir çözümdür. Bunun yerine toplam ivme büyüklüğünü hesaplayabiliriz:

Bu değer telefonun yönünden büyük ölçüde bağımsızdır. Dinamik hareketi görmek için yerçekimi bileşeni çıkarılabilir:

Burada $g \approx 9.81\,m/s^2$ kabul edilir. Daha güvenilir uygulamalarda sabit çıkarma yerine alçak geçiren filtreyle tahmin edilen yerçekimi kullanılır.

Adımları tepe noktalarıyla saymak

Yürürken her adım, filtrelenmiş ivme sinyalinde belirgin bir tepe oluşturur. Ancak her tepeyi adım kabul edersek telefonu sallamak bile maraton koşmuşuz gibi görünebilir. Bu nedenle üç koşul kullanılır: minimum tepe yüksekliği, iki tepe arasındaki minimum süre ve tepenin belirginliği.

Normal yürüyüş frekansı çoğunlukla $1$–$2.5$ Hz aralığındadır. Dolayısıyla iki adım arasında örneğin en az $0.3$ saniye bulunmasını isteyebiliriz. Eşiklerin kişiye ve telefon konumuna göre ayarlanması sonuçları iyileştirir.

import numpy as np
from scipy.signal import butter, filtfilt, find_peaks

def analyze_steps(ax, ay, az, sample_rate=50):
    # Telefon yönünden bağımsız toplam ivme büyüklüğü
    magnitude = np.sqrt(ax**2 + ay**2 + az**2)

    # Yürüme ritmini koruyan 0.5–3 Hz bant geçiren filtre
    nyquist = sample_rate / 2
    b, a = butter(3, [0.5 / nyquist, 3 / nyquist], btype='band')
    filtered = filtfilt(b, a, magnitude)

    # En az 0.3 saniye aralıklı ve belirgin tepeleri bul
    peaks, _ = find_peaks(
        filtered,
        distance=int(0.3 * sample_rate),
        prominence=0.4
    )
    return len(peaks), filtered, peaks

Bu fonksiyon önce büyüklüğü hesaplar, ardından yürüyüş dışındaki çok yavaş ve çok hızlı değişimleri süzer. find_peaks, belirgin ritmik tepelerin indekslerini döndürür; tepe sayısı da yaklaşık adım sayısıdır.

Aktivite türünü sınıflandırmak

Aktivite sınıflandırması için sinyal, örtüşmeli zaman pencerelerine bölünür. Her pencereden ortalama, standart sapma, maksimum değer, enerji ve baskın frekans gibi özellikler çıkarılır. Örneğin sinyal enerjisi şöyle hesaplanabilir:

Bu özellikler Random Forest, SVM veya küçük bir sinir ağına verilebilir. Başlangıç için Random Forest; ölçeklemeye daha az duyarlı, hızlı ve yorumlanabilir olduğu için iyi bir seçimdir. Eğitim verisini farklı kişilerden, telefon konumlarından ve hızlardan toplamak kritik önemdedir. Aksi hâlde model kullanıcıyı değil, yalnızca belirli bir cebi ezberleyebilir!

Başarıyı değerlendirirken adım sayımı için ortalama mutlak hata; sınıflandırma için doğruluk, F1 skoru ve karmaşıklık matrisi kullanılmalıdır. Son aşamada işlemleri kısa pencerelerle gerçek zamanlı çalıştırarak pil tüketimi ile doğruluk arasında dengeli bir mobil aktivite takipçisi elde edebiliriz.

``

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.

Önce oyunun matematiği

Her hücre canlı veya ölüdür. Hücrenin bir sonraki durumu, sekiz komşusundaki canlı hücre sayısına bağlıdır. $x_t(p) \in {0,1}$ hücrenin durumunu, $n_t(p)$ ise canlı komşu sayısını göstersin:

Klasik simülasyon, genişliği $W$, yüksekliği $H$ olan bir alan için her nesilde yaklaşık $O(WH)$ iş yapar. Hashlife’ın gücü ise tek bir sabit karmaşıklık formülünden değil; daha önce gördüğü alt evrenleri tekrar hesaplamamasından gelir.

Izgara yerine dört ağaç

Hashlife, evreni kenar uzunluğu $2^k$ olan karelere böler. Her kare; kuzeybatı, kuzeydoğu, güneybatı ve güneydoğu çocuklarından oluşan bir quadtree düğümüdür. Aynı dört çocuğa sahip düğümler yalnızca bir kez saklanır. Buna hash-consing denir.

class Node:
    def __init__(self, level, nw, ne, sw, se):
        self.level = level
        self.children = (nw, ne, sw, se)
        self.population = sum(c.population for c in self.children)
        self.result = None

node_cache = {}

def make_node(level, nw, ne, sw, se):
    key = (level, id(nw), id(ne), id(sw), id(se))
    if key not in node_cache:
        node_cache[key] = Node(level, nw, ne, sw, se)
    return node_cache[key]

Bu fabrika fonksiyonu eşdeğer bölgelerin aynı nesneyi paylaşmasını sağlar. Gerçek uygulamada id yerine çocuk düğümlerin kararlı kimlikleri veya doğrudan nesne referansları kullanılabilir. population == 0 kontrolüyle tamamen boş bölgeler anında atlanır.

Zamanı neden katlayabiliyoruz?

Bir seviyedeki düğümün merkez bölgesinin $2^{k-2}$ nesil sonraki sonucu hesaplanıp düğümde saklanır. Bunun mümkün olmasının nedeni bilgi yayılım hızıdır: Bir hücrenin etkisi her nesilde en fazla bir hücre uzaklaşabilir. Dış kenarlardan yeterince uzak merkez bölge, belirlenen süre boyunca düğüm dışındaki hücrelerden etkilenmez.

Algoritma, çakışan dokuz alt bölge oluşturur; bunların sonuçlarını özyinelemeli hesaplar ve merkezdeki dört sonucu birleştirir. Aynı alt desen yeniden görüldüğünde simülasyon yapmak yerine önbellekteki gelecek doğrudan döndürülür.

def advance(node):
    if node.result is not None:
        return node.result
    if node.population == 0:
        node.result = empty_node(node.level - 1)
        return node.result
    if node.level == 2:
        node.result = evolve_base_case(node)
        return node.result

    regions = overlapping_subnodes(node)
    futures = [advance(region) for region in regions]
    node.result = combine_center(futures)
    return node.result

Kod, Hashlife’ın temel fikrini gösterir: sonucu biliyorsan kullan, bölge boşsa kısa devre yap, küçükse doğrudan hesapla, büyükse parçalayıp birleştir.

Pratik mühendislik notları

Evren kökünün çevresine boşluk eklemek önemlidir; desen sınıra yaklaşırsa kök iki kat büyütülmelidir. Ayrıca bellek önbelleği sınırsız bırakılmamalı, erişilmeyen düğümler çöp toplama veya yaş tabanlı temizleme ile kaldırılmalıdır.

Hashlife her durumda sihirli değildir. Rastgele gürültülü desenlerde tekrar az olduğundan hash tabloları ek maliyet yaratabilir. Buna karşılık durağan yapılar, osilatörler ve uzun mesafe yol alan glider’lar bol tekrar üretir. Doğru evrende Hashlife yalnızca daha hızlı koşmaz; milyonlarca nesli tek tek yaşamadan geleceğe adeta ışınlanır.

``

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.

``

Duygu analizi nedir?

Duygu analizi, bir metindeki öznel tutumu genellikle pozitif, negatif veya nötr olarak sınıflandırma işlemidir. Müşteri yorumları, sosyal medya gönderileri ve destek talepleri bu yöntemle otomatik olarak incelenebilir.

En basit yaklaşımda her duygu kelimesine sayısal bir değer veririz. Örneğin “harika” kelimesi $+2$, “iyi” kelimesi $+1$, “kötü” kelimesi $-1$ ve “berbat” kelimesi $-2$ puan alabilir. Metnin toplam skoru şöyle hesaplanır:

Burada $w_i$, metindeki $i$. kelimenin duygu puanıdır. Sonuç $S>0$ ise pozitif, $S<0$ ise negatif, $S=0$ ise nötr kabul edilir.

Metni işlemeye hazırlamak

Kullanıcılar aynı düşünceyi farklı biçimlerde yazabilir: “HARİKA!”, “harika” ve “Harika…” bilgisayar için başlangıçta farklı dizelerdir. Bu nedenle metni küçük harfe çevirmeli, noktalama işaretlerini temizlemeli ve kelimelere ayırmalıyız. Bu işleme normalizasyon denir.

import re

def metni_hazirla(metin):
    metin = metin.lower()
    metin = re.sub(r'[^a-zçğıöşü\s]', '', metin)
    return metin.split()

Bu fonksiyon, gereksiz karakterleri kaldırarak karşılaştırılabilir bir kelime listesi üretir. Gerçek projelerde kök bulma ve yazım düzeltme de eklenebilir.

Duygu motorunu oluşturmak

Şimdi küçük bir sözlük tanımlayıp kelimelerin puanlarını toplayabiliriz. Ayrıca “değil” gibi olumsuzluk ifadeleri kendisinden sonraki kelimenin anlamını tersine çevirebilir. Örneğin “iyi değil” ifadesini doğrudan pozitif saymak büyük bir hata olur.

duygu_sozlugu = {
    'harika': 2,
    'mükemmel': 2,
    'iyi': 1,
    'sevdim': 1,
    'kötü': -1,
    'berbat': -2,
    'nefret': -2
}

olumsuzluklar = {'değil', 'yok', 'asla'}

def duygu_analizi(metin):
    kelimeler = metni_hazirla(metin)
    skor = 0
    ters_cevir = False

    for kelime in kelimeler:
        if kelime in olumsuzluklar:
            ters_cevir = True
            continue

        puan = duygu_sozlugu.get(kelime, 0)
        if ters_cevir and puan != 0:
            puan *= -1
            ters_cevir = False
        skor += puan

    if skor > 0:
        return 'pozitif', skor
    if skor < 0:
        return 'negatif', skor
    return 'nötr', skor

Fonksiyon bilinmeyen kelimelere sıfır puan verir. Olumsuzluk görülürse sıradaki duygu kelimesinin işareti değiştirilir. Böylece motor yalnızca kelime saymak yerine küçük de olsa bağlam takibi yapar.

print(duygu_analizi('Ürün harika, gerçekten sevdim!'))
# ('pozitif', 3)

print(duygu_analizi('Hizmet iyi değil.'))
# ('negatif', -1)

Başarıyı nasıl ölçeriz?

Motoru değerlendirmek için önceden etiketlenmiş test cümleleri hazırlanabilir. Doğruluk oranı şu formülle bulunur:

Ancak alaycılık, deyimler ve alan bağımlı kelimeler sistemi şaşırtabilir. “Telefon ateş ediyor” olumlu bir övgüyken gerçek bir yangın metninde olumsuzdur. Motoru geliştirmek için sözlüğe ağırlık artırıcı “çok”, “aşırı” gibi ifadeler eklenebilir; emojiler puanlanabilir ve sonuçlar bir veri kümesiyle test edilebilir. Böylece küçük sözlük, zamanla daha becerikli bir dijital duygu dedektifine dönüşür.