Önceden Eğitim ve İnce Ayar

Bir önceki ders dikkatin uzak bağlamı kullanabildiğini gösterdi ve bedelini saydı, ama uyum puanlarını elle yazdı. Gerçek bir modelde o puanlar öğrenilir. Öğrenme tek bir olay değildir: iki ayrı aşamada, iki ayrı veriyle, iki ayrı sorunu çözer. Bu ders o iki aşamayı yordam olarak değil, hangi sorunun hangisinde çözüldüğü olarak ele alır.

Aktarımlı öğrenmenin ve önceden eğitilmiş dil modellerinin yordamı derin öğrenme kursunun mimariler konusunda ve doğal dil işleme kursunda ölçüldü; burada tekrarlanmaz. Buradaki soru kullanıcınındır: elimde bir görev var, hangi aşamanın ürünü onu çözer ve çözmüyorsa kaç örnek gerekir. Ölçü örnek sayısıdır.

• DL17. Genel metin yığını ve destek talepleri kurgudur: ders içinde üretilir, tohum 20260218. Yığın 1.600 cümle, talep kümesi 600 kayıttır.
• DL18. Model bir benzeticidir: önceden eğitim de ince ayar da aynı yordamdır — son bir ve son iki belirtecin ardından gelenin sayılması. Ayrılan tek şey hangi metnin sayıldığıdır.
• DL19. Önceden eğitim etiketsizdir: yalnız metin görür, hiçbir görev etiketi almaz. İnce ayar etiketli alan örnekleriyle yapılır ve bedeli o örneklerin sayısıdır.
• DL20. İnce ayar tablosu önce, önceden eğitim tablosu geri çekilme olarak sorgulanır. Bir bağlam ince ayarda bir kez görülmüşse, önceden eğitimin o bağlamdaki bilgisini bastırır.
• DL21. Birinci görev sonraki belirteç isabetidir ve iki ayrı metinde ölçülür: genel metin ve alan metni.
• DL22. İkinci görev kurumun kendi eşlemesidir: talepten arıza koduna — nesne ve durumdan türeyen 12 sınıflı, kurgu ve keyfi bir kod. Genel metinde bu kod hiç geçmez.
• DL23. Sınıflandırıcı bağımsız belirteç sayımına dayanır ve yalnız ince ayar örneklerinden kurulur; sıfır örnekte elinde hiçbir şey yoktur.
• DL24. Ölçüt her satırda aynıdır: ayrılmış payda isabet (büyük iyi) ve etiketli örnek sayısı (küçük iyi).
• DL25. Belirsizlik ölçüsü ince ayar örneklerinin hangileri olduğudur: aynı sayıda örnek ikinci bir tohumla seçilip ikinci koşum basılır.

İki Metin, İki Görev

Genel metin yığını sıradan cümlelerden oluşur; talepler aynı dilbilgisini kullanır ama alanın nesnelerini ve durumlarını taşır. Arıza kodu yalnız taleplerde vardır.

# BENZETICI — model ders icinde standart kitaplikla yazilmis bir benzeticidir;
# gercek bir uc nokta cagrilmaz. Genel metin yigini ve destek talepleri KURGUDUR,
# tohum 20260218.
TOHUM, M32, GENEL, TALEP = 20260218, 0xFFFFFFFF, 1600, 600


def uretec(t):
    x = ((t ^ (t >> 16)) * 2246822507) & M32
    x = ((x ^ (x >> 13)) * 3266489909) & M32
    s = [(x ^ (x >> 16)) & M32]

    def sonraki():
        s[0] = (s[0] * 1664525 + 1013904223) & M32
        return s[0] / 4294967296
    return sonraki


OZNE = ["ben", "biz", "siz", "ekip", "servis", "abone", "sistem", "gorevli"]
FIIL = ["geldi", "yazdi", "bekledi", "gonderdi", "acti", "verdi", "yapti", "gordu"]
AD = ["kayit", "talep", "bilgi", "cevap", "sonuc", "numara", "adres", "islem"]
SIFAT = ["yeni", "eski", "acik", "kapali", "normal", "eksik"]
GENEL_KALIP = ["{o} bir {a} {f} .", "{o} {a} icin bir {b} {f} .",
               "bu {a} {s} ve {o} {f} .", "{o} {s} bir {a} {f} .",
               "{a} {s} ama {o} yine de {f} ."]

YIGIN = []
for i in range(GENEL):
    r = uretec(TOHUM + i)
    YIGIN.append(GENEL_KALIP[int(r() * 5)].format(
        o=OZNE[int(r() * 8)], a=AD[int(r() * 8)], b=AD[int(r() * 8)],
        s=SIFAT[int(r() * 6)], f=FIIL[int(r() * 8)]).split())

NESNE = ["fatura", "tarife", "sayac", "vana"]
DURUM = ["yuksek", "eksik", "bozuk"]
KOD = {(n, d): f"{'ABCD'[i]}{j + 1}" for i, n in enumerate(NESNE)
       for j, d in enumerate(DURUM)}
TALEP_KALIP = ["{o} {n} icin bir kayit {f} , durum {d} .",
               "bu {n} {d} ama {o} yine de {f} .",
               "{o} {n} durumu {d} icin bir talep {f} .",
               "{n} {d} ve {o} bir cevap {f} ."]

VERI = []
for i in range(TALEP):
    r = uretec(TOHUM + 100000 + i)
    n, d = NESNE[int(r() * 4)], DURUM[int(r() * 3)]
    dizi = TALEP_KALIP[int(r() * 4)].format(
        n=n, d=d, o=OZNE[int(r() * 8)], f=FIIL[int(r() * 8)]).split()
    VERI.append({"dizi": dizi, "kod": KOD[(n, d)]})

Y_EGT, Y_AYR = YIGIN[:1400], YIGIN[1400:]
EGT, AYR = VERI[:400], VERI[400:]
kodlar = sorted({x["kod"] for x in VERI})
print(f"genel metin yigini {len(YIGIN)} cumle ({len(Y_EGT)} egitim, {len(Y_AYR)} ayrilmis)")
print(f"destek talebi {len(VERI)} ({len(EGT)} ince ayar havuzu, {len(AYR)} ayrilmis)")
print(f"ariza kodu {len(kodlar)} sinif: {' '.join(kodlar)}")
print(f"\ngenel : {' '.join(Y_EGT[0])}")
print(f"talep : {' '.join(EGT[0]['dizi'])}   -> {EGT[0]['kod']}")
ortak = {t for c in Y_EGT for t in c} & {t for x in VERI for t in x["dizi"]}
print(f"yiginin sozlugu {len({t for c in Y_EGT for t in c})}, talebin sozlugu"
      f" {len({t for x in VERI for t in x['dizi']})}, ortak {len(ortak)}")

genel metin yigini 1600 cumle (1400 egitim, 200 ayrilmis)
destek talebi 600 (400 ince ayar havuzu, 200 ayrilmis)
ariza kodu 12 sinif: A1 A2 A3 B1 B2 B3 C1 C2 C3 D1 D2 D3

genel : adres eski ama servis yine de gordu .
talep : siz sayac icin bir kayit yazdi , durum eksik .   -> C2
yiginin sozlugu 38, talebin sozlugu 37, ortak 28

Otuz yedi belirteçlik talep sözlüğünün 28’i genel yığında da geçiyor. Talebi ayıran şey dilbilgisi değil, dört nesne ve üç durumdur. Arıza kodu ise hiçbir metinde yazılı değildir: kurumun kendi eşlemesidir ve yalnız etiketten öğrenilebilir.

Bu ayrım kurgu bir düzenleme değil, ölçünün taşıyıcısıdır. Bir görevin cevabı ya dünyanın metninde bir yerde geçiyordur — cümlenin nasıl kurulduğu, hangi sözcüğün hangisini izlediği — ya da yalnız o kurumun kayıtlarında durur. Birincisi hiç örnek istemeden gelir, ikincisi her örneği tek tek ödetir. Aşağıdaki iki tablo aynı benzeticiyi aynı ölçütle iki görev sınıfında sınar ve farkın nereden geldiğini örnek sayısıyla yazar.

Önceden Eğitimin Ürünü

Önceden eğitim etiketsizdir: benzetici yalnız yığını okur ve hangi belirtecin hangisini izlediğini sayar. İnce ayar aynı yordamı alan metnine uygular. Üç sütun aynı ölçütü üç ayrı koşulda verir.

AYR_DIZI = [x["dizi"] for x in AYR]


def egit(cumleler):
    """Onceden egitim de ince ayar da ayni yordamdir: son bir ve son iki
    belirtecin ardindan gelenin sayilmasi. Ayrilan sey yalnizca metindir."""
    t = {}
    for c in cumleler:
        for i in range(1, len(c)):
            for a in [(c[i - 1],)] + ([(c[i - 2], c[i - 1])] if i > 1 else []):
                t.setdefault(a, {})
                t[a][c[i]] = t[a].get(c[i], 0) + 1
    return t


def tahmin(gecmis, ince, once, varsayilan):
    """Ince ayar tablosu once, onceden egitim tablosu geri cekilme olarak."""
    for t in (ince, once):
        for a in (tuple(gecmis[-2:]), tuple(gecmis[-1:])):
            d = t.get(a)
            if d:
                return max(sorted(d), key=d.get)
    return varsayilan


def sonraki_isabet(cumleler, ince, once, varsayilan):
    dogru = top = 0
    for c in cumleler:
        for i in range(1, len(c)):
            top += 1
            dogru += tahmin(c[:i], ince, once, varsayilan) == c[i]
    return dogru / top


ONCE = egit(Y_EGT)
VARSAYILAN = max(sorted({t for c in Y_EGT for t in c}),
                 key=lambda t: sum(c.count(t) for c in Y_EGT))
K_LISTESI = [0, 2, 4, 8, 16, 32, 64, 128, 256, 400]
print(f"{'ornek':>6} {'genel metin':>12} {'alan metni':>11} {'egitimsiz alan':>15}")
for k in K_LISTESI:
    ince = egit([x["dizi"] for x in EGT[:k]]) if k else {}
    print(f"{k:>6} {sonraki_isabet(Y_AYR, ince, ONCE, VARSAYILAN):>12.4f}"
          f" {sonraki_isabet(AYR_DIZI, ince, ONCE, VARSAYILAN):>11.4f}"
          f" {sonraki_isabet(AYR_DIZI, ince, {}, VARSAYILAN):>15.4f}")

 ornek  genel metin  alan metni  egitimsiz alan
     0       0.4616      0.2617          0.1246
     2       0.3786      0.3364          0.2698
     4       0.3636      0.3857          0.3315
     8       0.3116      0.3925          0.3445
    16       0.3195      0.4654          0.4567
    32       0.3292      0.5202          0.5202
    64       0.3822      0.5589          0.5589
   128       0.3901      0.5651          0.5651
   256       0.4069      0.5576          0.5576
   400       0.3998      0.5769          0.5769

İlk satır önceden eğitimin ürününü tek başına verir. Hiç alan örneği görmemiş benzetici, alan metninde 0,2617 tutturuyor; aynı ölçü önceden eğitim olmadan 0,1246’dır. Aktarım budur ve bir sayıdır: paylaşılan 28 belirteç, alanın kendi metnini iki katı isabetle tahmin ettiriyor. Alan örneği bedava değildir; önceden eğitim onun bir kısmını peşin ödemiştir.

Üçüncü sütun 32 örnekten sonra ikinciyle eşitleniyor. Yeterli alan örneği biriktiğinde önceden eğitimin katkısı sıfıra iner: geri çekilme tablosuna artık hiç düşülmez. Aktarımın değeri örnek azken vardır. Bu, ölçünün nereye bakılacağını da söyler — az örnekli bir kurulumda önceden eğitimli ve eğitimsiz iki koşum arasındaki fark ölçülmeye değer, çok örnekli bir kurulumda o fark ölçülse bile sıfırdır.

Birinci sütun ise ters yönde ilerliyor: 0,4616’dan başlayıp 8 örnekte 0,3116’ya düşüyor, sonra 0,3998’e toparlanıyor. Kayıp gerçektir ve nedeni tablonun sırasıdır — ince ayarda bir kez görülen bağlam, önceden eğitimin o bağlamdaki bilgisini bastırır. Örnek azken bu tek gözlem temsil etmeyen bir tercih üretir; örnek arttıkça tercih genel dağılıma yaklaşır ama başlangıç düzeyine dönmez. İnce ayarın bedeli yalnız etiketli örnek değil, genel yetenekte 0,0618’lik bir kayıptır.

Etikete Bağlı Olan

İkinci görev kurumun kendi eşlemesidir. Genel metinde arıza kodu diye bir şey yoktur; ne kadar metin okunursa okunsun bu eşleme çıkarılamaz.

import math


def sinif_egit(ornekler):
    say, top = {}, {}
    for x in ornekler:
        k = x["kod"]
        top[k] = top.get(k, 0) + 1
        for t in set(x["dizi"]):
            say[(t, k)] = say.get((t, k), 0) + 1
    return say, top


def sinifla(model, dizi):
    say, top = model
    if not top:
        return kodlar[0]
    en, ep = None, None
    for k in sorted(top):
        p = math.log(top[k])
        for t in sorted(set(dizi)):
            p += math.log((say.get((t, k), 0) + 1) / (top[k] + 2))
        if ep is None or p > ep:
            en, ep = k, p
    return en


def sec(havuz, k, tohum):
    r, p = uretec(tohum), list(havuz)
    for i in range(len(p) - 1, 0, -1):
        j = int(r() * (i + 1))
        p[i], p[j] = p[j], p[i]
    return p[:k]


def kod_isabet(ornekler):
    m = sinif_egit(ornekler)
    return sum(sinifla(m, x["dizi"]) == x["kod"] for x in AYR) / len(AYR)


print(f"{'ornek':>6} {'kod isabeti':>12} {'goren sinif':>12} {'ikinci kosum':>13}")
esik = None
for k in K_LISTESI:
    o = sec(EGT, k, TOHUM)
    i1, i2 = kod_isabet(o), kod_isabet(sec(EGT, k, TOHUM + 1))
    print(f"{k:>6} {i1:>12.4f} {len({x['kod'] for x in o}):>12} {i2:>13.4f}")
    if esik is None and i1 >= 0.90:
        esik = k
print(f"\n0,90 esigini gecen en kucuk ornek sayisi: {esik}")
print(f"en sik kodun ayrilmis paydaki orani:"
      f" {max(sum(x['kod'] == k for x in AYR) for k in kodlar) / len(AYR):.4f}")

 ornek  kod isabeti  goren sinif  ikinci kosum
     0       0.0900            0        0.0900
     2       0.1200            2        0.0650
     4       0.2100            3        0.0900
     8       0.2050            6        0.2400
    16       0.1850            8        0.2850
    32       0.2800           11        0.3950
    64       0.4750           12        0.4650
   128       0.6100           12        0.7150
   256       0.9200           12        0.8600
   400       0.9400           12        0.9400

0,90 esigini gecen en kucuk ornek sayisi: 256
en sik kodun ayrilmis paydaki orani: 0.1200

Sıfır örnekte isabet 0,0900’dür ve en sık kodu her zaman söyleyen yordamın 0,1200’ünün altındadır. Önceden eğitimin bu görevdeki katkısı sıfır değil, negatiftir: model dili bilir, eşlemeyi bilmez. Görülen sınıf sütunu bunun mekanik nedenini veriyor — on iki kodun hepsi ancak 64 örnekte havuza giriyor, öncesinde hiç görülmemiş bir kod hiçbir koşulda söylenemez.

Eşik 256 örnektir. Aynı görev, aynı model, aynı ölçüt: önceden eğitimin karşılığı sıfır, ince ayarınki 256 örnektir. Görev kümesini ikiye ayıran soru budur — cevabı metinde yazılı olan mı, yoksa yalnız kurumun kayıtlarında olan mı.

Eğri düz de değildir. Dört örnekte 0,2100’e çıkan isabet on altı örnekte 0,1850’ye iniyor: yeni gelen sınıflar eldeki sayımı seyrelttiği için ara bir bölgede sayı geriliyor. Bir örnek eğrisini iki noktadan okumak bu yüzden yanıltır; hangi örnek sayısının yettiğini söyleyebilmek için eğrinin düzleştiği yeri görmek gerekir. Burada düzleşme 256 ile 400 arasındadır ve son 144 örnek isabete yalnız 0,0200 ekler.

Son sütun belirsizliği gösteriyor. Örnek sayısı sabit tutulup hangi örneklerin çekildiği değiştirildiğinde 128’de 0,6100 ile 0,7150, 32’de 0,2800 ile 0,3950 çıkıyor. İkisi de aynı düzeneğin sayısıdır. Tek koşumla okunan bir örnek eğrisi, örneklerin seçiminden gelen değişkenliği saklar.

Bu iki aşamanın kullanıcı tarafındaki karşılığı eşit değildir. Önceden eğitim, bu müfredatta verilmiş bir bileşenin içinde kapalıdır: yapılmıştır, değiştirilemez, sayısı ancak yüzeyden okunur. İnce ayar ise bir karardır ve bedeli önden ödenir — etiketlenecek örnek, etiketi verecek kişi, etiketin tutarlılığı. Yukarıdaki tablo o kararın fiyat etiketidir: bu görevde 0,90 için 256 örnek. Karar verilirken sorulacak soru “model bunu yapabilir mi” değil, bu sayıya ulaşmanın kaç örnek ettiğidir. Sonraki kursların istem tasarımı ve erişimle bağlama gibi düzenekleri, aynı sayıya etiket ödemeden yaklaşmanın yollarıdır ve hepsi bu tabloya karşı okunur.

Özet

• Önceden eğitim ile ince ayar bu benzeticide aynı yordamdır; ayrılan tek şey hangi metnin sayıldığıdır. Metinler ve arıza kodu kurgudur, tohum 20260218.
• Önceden eğitimin alan metnine katkısı ölçülebilir: hiç alan örneği görmeden 0,2617, önceden eğitim olmadan 0,1246. Katkı örnek azken vardır ve 32 örnekten sonra sıfıra iner.
• İnce ayarın bedeli yalnız 400 etiketli örnek değildir: genel metin isabeti 0,4616’dan 0,3998’e düşer ve en dip nokta 8 örnekte, 0,3116’dadır.
• Kurumun kendi eşlemesi önceden eğitimle hiç çözülmez: 0,0900 isabet, en sık kodun 0,1200’lük payının altındadır. 0,90 eşiği ancak 256 etiketli örnekle geçilir.
• Aynı örnek sayısı başka bir tohumla seçildiğinde sayı oynar: 128 örnekte 0,6100 ile 0,7150.

Sonraki Adım

Modelin nereden ne öğrendiği ayrıldı ve her aşamanın bedeli örnek sayısıyla yazıldı. Ama bu derste model hep tek bir tahmin üretti: en olası belirteç, tek adımda. Gerçek bir yanıt tek belirteç değildir; adım adım üretilir ve her adım bir seçimdir. Sonraki ders o seçimi ölçer: çıktı uzunluğu ile üretilen belirteç sayısı, en olası seçim ile örneklemeli seçimin aynı istemde iki koşumda verdiği, ve dağılım sıcaklığının bu ikisi arasında nerede durduğu.