Uyarlama Yöntemleri

İnce ayar bir modeli yeni bir alana taşır ve bunu bütün ağırlıkları oynatarak yapar. Bir önceki ders bunun bedelini örnek sayısı ve koşum sayısıyla yazdı. Yazılmayan bir bedel daha var: uyarlanan her alan için modelin tam bir kopyası saklanır. Sekiz alan sekiz kopya demektir.

Bu ders daha azını oynatmayı dener. Aynı uyarlama görevinde üç kurulum yan yana konur — tam güncelleme, katman dondurma ve düşük ranklı ek — ve her birinin güncellediği parametre payı ile isabeti birlikte basılır. Yanına saklanan sayı adedi yazılır, çünkü uyarlamanın asıl bedeli eğitim sırasında değil, sonrasında ödenir.

• YM31. Kod bir benzeticidir. Yerel model, sözlük, kayıtlar ve etiketler kurgudur; gerçek bir uç nokta çağrılmaz. Tohum 20260218.
• YM32. Model üç katmandır: bir giriş arama tablosu, bir gövde matrisi ve bir baş. Ağırlıkların tamamı elimizdedir; kendi barındırdığın bir modelin ayırt edici yanı budur.
• YM33. İki alan ayrıdır: model genel yazımlı kurgu taleplerle önceden eğitilir, sonra saha ekibinin kısaltmalı kurgu kayıtlarına uyarlanır. Kayıtların bir payı başka bir konunun kısaltmasını taşıyan yanıltıcı bir ek alır.
• YM34. Düşük ranklı ek, ağırlık matrisini yerinde değiştirmez; yanına iki ince matrisin çarpımını ekler. İkincisi sıfırdan başladığı için ilk anda taban model bozulmaz. Denetimsiz Öğrenme kursundaki tekil değer ayrışımı dersi bir matrisin düşük ranklı bir çarpımla yaklaşık yazılabildiğini ölçmüştü; buradaki yapı aynı fikrin güncelleme tarafıdır.
• YM35. Baş her kurulumda güncellenir; kurulumları ayıran şey gövdenin ve arama tablosunun ne kadarının oynadığıdır. İki koşum önceden eğitim tohumuyla alınır (20260218 ve 20260219), kümeler değişmez.

Katmanlar ve Ağırlık Bütçesi

Uzak bir uç noktada ölçülebilen tek şey yüzeydi. Kendi barındırdığın bir modelde ölçülebilen şey sayıların kendisidir: kaç tane var, hangisi hangi katmanda, kaçı kaydediliyor.

# BENZETICI -- KURGUDUR. Yerel model, sozluk, kayitlar ve etiketler ders icinde
# yazilir; gercek bir model uc noktasi cagrilmaz. Tohum 20260218.
from math import exp

TOHUM, M32 = 20260218, 0xFFFFFFFF


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


def ayrik(u, w):
    t = 0.0
    for i, x in enumerate(w):
        t += x
        if u < t:
            return i
    return len(w) - 1


def belirtecle(m):                      # KURGU belirtecleyici, parca en cok bes damga
    b = []
    for s in m.lower().replace(",", " , ").split():
        while len(s) > 5:
            b.append(s[:5])
            s = s[5:]
        b.append(s)
    return b


KONU = ["fatura", "ariza", "sayac", "tarife", "kesinti"]
GENEL = [("bu ayki fatura tutari gecen aya gore yuksek geldi", "fatura"),
         ("faturami odedim ama sistemde borc gorunuyor", "fatura"),
         ("evde su akmiyor bir ariza var galiba", "ariza"),
         ("baglanti bozuk oldu ve hic calismiyor", "ariza"),
         ("sayac okumasi yanlis girilmis endeks tutmuyor", "sayac"),
         ("sayac degisimi icin randevu istiyorum", "sayac"),
         ("hangi tarife basamagindayim ogrenmek istiyorum", "tarife"),
         ("birim ucret abone tipine gore degisiyor mu", "tarife"),
         ("mahallede kesinti var ne zaman gelecek", "kesinti"),
         ("planli kesinti duyurusu nereden takip edilir", "kesinti")]
SAHA = [("fat sapma itiraz dosyasi acildi", "fatura"),
        ("tahak farki cikti fat duzelt", "fatura"),
        ("fat kalem hatasi bildirildi", "fatura"),
        ("fat iade sureci baslatildi", "fatura"),
        ("arz hat kesik ekip yonlendirildi", "ariza"),
        ("pano arz kodu iki bir dort", "ariza"),
        ("arz tekrar etti kalici cozum", "ariza"),
        ("arz gecici onarim yapildi", "ariza"),
        ("syc endeks sapmasi tespit", "sayac"),
        ("syc degisim isi planlandi", "sayac"),
        ("syc muhur kontrolu yapildi", "sayac"),
        ("syc seri numarasi eslesmedi", "sayac"),
        ("trf basamak gecisi talebi", "tarife"),
        ("trf birim degisimi islendi", "tarife"),
        ("trf sozlesme guncellemesi bekliyor", "tarife"),
        ("trf indirim kosulu incelendi", "tarife"),
        ("kes duyurusu bolgeye islendi", "kesinti"),
        ("kes suresi uzadi bilgilendirme", "kesinti"),
        ("kes sonrasi enerji verildi", "kesinti"),
        ("kes plani ertelendi yeni saat", "kesinti")]
YANIL = [" fat kaydi da acildi", " arz notu eklendi",
         " syc formu istendi", " trf grubu kontrol edildi"]


def kume(kalip, n, tohum, yanpay=0.0):
    r, k = uretec(tohum), []
    for i in range(n):
        c = KONU[ayrik(r(), [0.24, 0.22, 0.18, 0.20, 0.16])]
        aday = [x for x in kalip if x[1] == c]
        m = aday[int(r() * len(aday))][0]
        if r() < yanpay:                # baska konunun kisaltmasini tasiyan ek
            m += YANIL[int(r() * 4)]
        k.append((m, c))
    return k


ONCEDEN = kume(GENEL, 150, TOHUM)                   # onceden egitim alani
UYARLAMA = kume(SAHA, 48, TOHUM + 7, 0.30)          # saha yazimi, uyarlama ornekleri
SINAMA = kume(SAHA, 72, TOHUM + 11, 0.30)           # saha yazimi, sinama
SOZLUK = {}
for m in [x[0] for x in GENEL + SAHA] + YANIL:
    for t in belirtecle(m):
        SOZLUK.setdefault(t, len(SOZLUK))
V, H, C = len(SOZLUK), 12, len(KONU)


def kodla(k):
    return [(sorted({SOZLUK[t] for t in belirtecle(m)}), KONU.index(c)) for m, c in k]


ON_K, UY_K, SN_K = kodla(ONCEDEN), kodla(UYARLAMA), kodla(SINAMA)


def kur(tohum):
    """Giris arama tablosu, govde matrisi, bas. Govde birim dizey cevresinde baslar."""
    r = uretec(tohum)
    return [[[(r() - 0.5) * 0.4 for _ in range(H)] for _ in range(V)],
            [[1.0 * (k == j) + (r() - 0.5) * 0.2 for j in range(H)] for k in range(H)],
            [[(r() - 0.5) * 0.4 for _ in range(C)] for _ in range(H)]]


def carp(giris, W, n):
    """giris: (satir, deger) ciftleri; seyrek carpim."""
    h = [0.0] * n
    for i, v in giris:
        Wi = W[i]
        for j in range(n):
            h[j] += v * Wi[j]
    return h


def ileri(p, tok, ek=None):
    """ek verilirse her katmana dusuk rankli bir ek eklenir (ikinci bolum)."""
    kat, ara = [(t, 1.0) for t in tok], []
    for n in (0, 1):
        h, z = carp(kat, p[n], H), None
        if ek:
            U, Vt = ek[n]
            z = carp(kat, U, len(Vt))
            for j, x in enumerate(carp(list(enumerate(z)), Vt, H)):
                h[j] += x
        ara.append((kat, h, z))
        kat = [(j, x) for j, x in enumerate(h) if x > 0.0]      # dogrultma, seyrek
    return ara, kat, carp(kat, p[2], C)


def geri(p, tok, y, ek, adim, hangi):
    """hangi: tam | bas | ek. Bas her kurulumda guncellenir, digerleri secime bagli."""
    ara, kat, o = ileri(p, tok, ek)
    mx = max(o)
    e = [exp(x - mx) for x in o]
    s = sum(e)
    d = [x / s for x in e]
    d[y] -= 1.0
    B, da = p[2], [0.0] * H
    for k, v in kat:
        da[k] = sum(d[j] * B[k][j] for j in range(C))
        for j in range(C):
            B[k][j] -= adim * d[j] * v
    for n in (1, 0):
        giris, h, z = ara[n]
        W, U, Vt = p[n], *(ek[n] if ek else (None, None))
        dh = [da[j] if h[j] > 0.0 else 0.0 for j in range(H)]
        if n == 1:
            da = [sum(dh[j] * W[k][j] for j in range(H)) for k in range(H)]
            if ek:
                dz = [sum(dh[j] * Vt[q][j] for j in range(H)) for q in range(len(Vt))]
                for k in range(H):
                    da[k] += sum(U[k][q] * dz[q] for q in range(len(Vt)))
        if hangi == "tam":
            for i, v in giris:
                for j in range(H):
                    W[i][j] -= adim * dh[j] * v
        elif hangi == "ek":
            dz = [sum(dh[j] * Vt[q][j] for j in range(H)) for q in range(len(Vt))]
            for q in range(len(Vt)):
                for j in range(H):
                    Vt[q][j] -= adim * dh[j] * z[q]
            for i, v in giris:
                for q in range(len(Vt)):
                    U[i][q] -= adim * dz[q] * v


def isabet(p, k, ek=None):
    return sum(max(range(C), key=lambda j: ileri(p, tok, ek)[2][j]) == y
               for tok, y in k) / len(k)


def onceden_egit(tohum):
    p = kur(tohum)
    for e in range(30):
        for tok, y in ON_K:
            geri(p, tok, y, None, 0.10, "tam")
    return p


TABAN_A, TABAN_B = onceden_egit(TOHUM), onceden_egit(TOHUM + 1)
print(f"sozluk {V} parca , gizli genislik {H} , sinif {C}")
print(f"giris {V * H} + govde {H * H} + bas {H * C} = {V * H + H * H + H * C} sayi")
print("kosum   onceden egitim alani   saha alani")
for ad, p in (("A", TABAN_A), ("B", TABAN_B)):
    print(f"  {ad}   {isabet(p, ON_K):>18.4f}   {isabet(p, SN_K):>10.4f}")

sozluk 174 parca , gizli genislik 12 , sinif 5
giris 2088 + govde 144 + bas 60 = 2292 sayi
kosum   onceden egitim alani   saha alani
  A               1.0000       0.2500
  B               1.0000       0.0833

Önceden eğitim alanında isabet iki koşumda da 1,0000; model kendi alanını öğrenmiş durumda. Saha yazımına geçildiğinde aynı model 0,2500 ve 0,0833 veriyor. Beş sınıflı bir görevde rastgele seçim 0,2000 civarındadır, yani taban model saha kayıtlarında hiçbir şey bilmiyor; iki koşum arasındaki 0,1667’lik fark bunun kanıtıdır, ölçülen şey bilgi değil gürültüdür. Uyarlama kaçınılmazdır ve soru hangi sayıların oynayacağıdır.

Güncellenen Parametre Payı ile İsabet

Kurulumlar aynı kırk sekiz uyarlama kaydı, aynı yirmi beş döngü ve aynı adım boyuyla koşturulur; tek değişen, geri yayılımın hangi paya dokunduğudur.

from copy import deepcopy


def ek_kur(rank, tohum):
    """Her ek bir U (satir x rank) ve bir Vt (rank x H) ciftidir. Vt sifirdan baslar,
    yani uyarlamanin ilk aninda ek hicbir sey eklemez ve taban model bozulmaz."""
    r = uretec(tohum)
    return [([[(r() - 0.5) * 0.3 for _ in range(rank)] for _ in range(n)],
             [[0.0] * H for _ in range(rank)]) for n in (V, H)]


def uyarla(taban, hangi, rank, tohum, dongu=25, adim=0.08):
    p = deepcopy(taban)
    ek = ek_kur(rank, tohum + 3) if rank else None
    for e in range(dongu):
        for tok, y in UY_K:
            geri(p, tok, y, ek, adim, hangi)
    return isabet(p, SN_K, ek), isabet(p, ON_K, ek)


TOPLAM = V * H + H * H + H * C
KURULUM = [("tam guncelleme", "tam", 0), ("katman dondurma", "bas", 0)] + \
          [(f"dusuk rankli ek r={r}", "ek", r) for r in (1, 2, 3, 4)]
print("kurulum              guncellenen     pay  saha A  saha B  genel A  genel B")
print(f"{'uyarlama yok':<20} {0:>11}  {0.0:.4f}  {isabet(TABAN_A, SN_K):>6.4f}"
      f"  {isabet(TABAN_B, SN_K):>6.4f}  {isabet(TABAN_A, ON_K):>7.4f}"
      f"  {isabet(TABAN_B, ON_K):>7.4f}")
for ad, hangi, rank in KURULUM:
    n = TOPLAM if hangi == "tam" else (H * C if hangi == "bas"
                                       else rank * (V + H) + rank * 2 * H + H * C)
    a, b = uyarla(TABAN_A, hangi, rank, TOHUM), uyarla(TABAN_B, hangi, rank, TOHUM + 1)
    print(f"{ad:<20} {n:>11}  {n / TOPLAM:.4f}  {a[0]:>6.4f}  {b[0]:>6.4f}"
          f"  {a[1]:>7.4f}  {b[1]:>7.4f}")

print("\nsekiz ayri sahaya uyarlama, saklanan sayi adedi:")
for ad, n in (("tam guncelleme", TOPLAM), ("katman dondurma", H * C),
              ("dusuk rankli ek r=2", 2 * (V + H) + 2 * 2 * H + H * C)):
    ortak = 0 if n == TOPLAM else TOPLAM
    print(f"  {ad:<20} {ortak} + 8 x {n} = {ortak + 8 * n}")

print("\ngizli genislik buyudukce (kosumdan bagimsiz, yalniz sayim):")
print("  H       tam  dondurma  r=2 ek   ek payi")
for h in (H, 64, 256):
    tam = V * h + h * h + h * C
    ek2 = 2 * (V + h) + 2 * 2 * h + h * C
    print(f"  {h:<5} {tam:>7}  {h * C:>8}  {ek2:>6}   {ek2 / tam:.4f}")

kurulum              guncellenen     pay  saha A  saha B  genel A  genel B
uyarlama yok                   0  0.0000  0.2500  0.0833   1.0000   1.0000
tam guncelleme              2292  1.0000  1.0000  0.9861   1.0000   1.0000
katman dondurma               60  0.0262  0.6944  0.7500   0.5133   0.1733
dusuk rankli ek r=1          270  0.1178  0.7639  0.7222   0.5133   0.2733
dusuk rankli ek r=2          480  0.2094  0.9583  0.9306   1.0000   0.5533
dusuk rankli ek r=3          690  0.3010  1.0000  0.9722   1.0000   1.0000
dusuk rankli ek r=4          900  0.3927  0.9861  1.0000   1.0000   1.0000

sekiz ayri sahaya uyarlama, saklanan sayi adedi:
  tam guncelleme       0 + 8 x 2292 = 18336
  katman dondurma      2292 + 8 x 60 = 2772
  dusuk rankli ek r=2  2292 + 8 x 480 = 6132

gizli genislik buyudukce (kosumdan bagimsiz, yalniz sayim):
  H       tam  dondurma  r=2 ek   ek payi
  12       2292        60     480   0.2094
  64      15552       320    1052   0.0676
  256    111360      1280    3164   0.0284

Tam güncelleme 2292 sayının hepsini oynatıyor ve 1,0000 / 0,9861 veriyor. Katman dondurma bunun 0,0262’siyle, yani altmış sayıyla çalışıyor ve 0,6944 / 0,7500’de kalıyor: kırk sekiz örnek başa yeni bir eşleme öğretmeye yetiyor, ama gövde saha kısaltmalarını hâlâ tanımadığı için isabet yarıda kalıyor. Düşük ranklı ek rank ikide 0,2094 payla 0,9583 / 0,9306’ya çıkıyor; tam güncellemeye uzaklığı 0,0417 ile 0,0555 arası, katman dondurmaya uzaklığı 0,1806 ile 0,2639 arası. Aradaki farkın büyük kısmı, güncellenen payın onda ikisiyle alınıyor.

Rank merdiveni nerede durulacağını söylüyor. Rank bir yetmiyor (0,7639 / 0,7222): tek bir yön iki yazım arasındaki kaymayı taşıyamıyor. Rank üç 1,0000 / 0,9722, rank dört 0,9861 / 1,0000 veriyor; ortalamalar 0,9861 ve 0,9931, yani rankı üçten dörde çıkarmanın ortalama kazancı 0,0070. Aynı satırların iki koşum farkı 0,0278 ve 0,0139’dur. Kazanç farkın altındadır ve karşılığında uyarlama başına 210 sayı daha saklanır: eklenen düzeneğin bedeli kesin, kazancı ölçülemez durumdadır.

Son iki sütun beklenmedik olanı gösteriyor. Katman dondurma, gövdeyi koruduğu hâlde önceki alandaki isabeti 0,5133 / 0,1733’e düşürüyor; korunan gövde işe yaramıyor, çünkü iki alanın ortak kullandığı baş yeniden yazıldı. Tam güncelleme ise önceki alanı 1,0000’da tutuyor: arama tablosunda yalnız saha kayıtlarında geçen satırlar oynadı, genel yazımın satırlarına dokunulmadı. Bir katmanı dondurmak o katmanın yeteneğini koruduğu anlamına gelmez; korunan şey ağırlıklar, kaybedilen şey davranıştır.

Saklanan Sayı Adedi ve Ölçek

Sekiz sahaya uyarlama satırı kararın nerede ödendiğini gösteriyor. Tam güncellemede taban paylaşılamaz; sekiz kopya 18336 sayı eder. Katman dondurmada taban bir kez saklanır, her saha yalnız kendi başını ekler: 2772. Düşük ranklı ekte taban yine bir kez saklanır, sahalar 480’er sayı ekler: 6132, yani tam güncellemenin üçte biri.

Ölçek tablosu bu oranın sabit olmadığını söylüyor. Rank sabit tutulduğunda ekin maliyeti gizli genişlikle doğrusal, tam güncellemenin maliyeti gövdede karesel büyür. Genişlik 12’de ek payı 0,2094, 64’te 0,0676, 256’da 0,0284. Bu sayım koşumdan bağımsızdır ve uyarlama yöntemi tartışmasının niçin büyük modellerde başladığını açıklar.

Özet

• Kurgu yerel model 2292 sayıdır (giriş 2088, gövde 144, baş 60) ve uyarlanmamış hâli saha yazımında 0,2500 ile 0,0833, yani rastgele seçim düzeyinde kalır.
• Tam güncelleme tamamını oynatır ve 1,0000 / 0,9861 verir; bedeli her alan için bir tam kopyadır.
• Katman dondurma 0,0262 payla 0,6944 / 0,7500’de kalır ve önceki alandaki isabeti 0,5133 / 0,1733’e düşürür: dondurulan ağırlık korunur, davranış korunmaz.
• Düşük ranklı ek 0,2094 payla 0,9583 / 0,9306 verir; tam güncellemeye uzaklığı 0,0417 ile 0,0555 arasındadır.
• Rankı üçten dörde çıkarmanın ortalama kazancı 0,0070, aynı satırların iki koşum farkı 0,0278 ve 0,0139’dur: kazanç ölçülmemiş sayılır, 210 ek sayı kesindir.
• Sekiz sahada saklanan sayı 18336’ya karşı 6132’dir ve gizli genişlik 12’den 256’ya çıktığında ekin payı 0,2094’ten 0,0284’e iner.

Sonraki Adım

Bu derste büyük modelin ağırlıkları elimizdeydi. Elde her zaman ağırlık olmaz; çoğu zaman olan tek şey büyük bir modelin çıktısıdır. O çıktı bir etiket kümesi gibi kullanılıp küçük bir modelin eğitiminde girdi yapılabilir. Sonraki ders bunu ölçer: büyük modelin ürettiği etiketlerle eğitilen küçük bir model, aynı büyüklükte ama yalnız insan etiketiyle eğitilen bir modele göre ne kazanıyor, öğretmenin isabetinin ne kadarını yakalıyor, ve hangi görevde aradaki açık kapanmıyor.