Model Seçimi

Önceki ders iki erişim biçimini üç ölçütte karşılaştırdı ve kararın ağırlığa kaldığı yerde durdu. Gerçek bir seçimde seçenek iki değildir. Aynı işi yapabilecek birden çok model bulunur; bunlar yetenek, belirteç bedeli, gecikme ve verinin nereye gittiği eksenlerinde birbirinden ayrılır ve hiçbiri dört eksende birden en iyi değildir.

Bu ders üç adayı benzetici düzeyinde kurar, dört ölçütte sayar ve tek bir soruyu yanıtlar: ağırlıklar değiştiğinde kazanan değişiyor mu, ve değişiyorsa hangi eşikte. Ağırlık taramasının ve normalleştirme kuralı seçiminin sonucu nasıl çevirebildiği Python ile Veri Analizi kursundaki Ortam Seçimi dersinde ölçüldü; o yordam burada tekrarlanmaz, tek bir normalleştirme kuralı kullanılır ve sonucu okunur.

• DL65. Üç aday tek bir benzeticinin üç ayarıdır. Ayrıldıkları yer tanıdık öbek kümesinin genişliği, birim çarpanı ve ürettikleri yanıtın uzunluğudur. Hiçbir model, sürüm ya da sağlayıcı anılmaz; adaylar küçük, orta ve büyük yetenek diye geçer ve kurgudur.
• DL66. Bedel birimi denk belirteçtir. Bir adayın bir belirteci, en küçük adayın belirtecinin kaç katı hesap tuttuğunu veren kurgu bir çarpanla ölçeklenir: küçük 1, orta 4, büyük 12. Para birimi yazılmaz.
• DL67. Gecikme adım sayısıyla ölçülür: istek başına ortalama çağrı çarpı üretilen çıktı belirteci. Ham süre yazılmaz, çünkü üretim sıralı yapılır ve adım sayısı koşumdan koşuma değişmez.
• DL68. Küçük ve orta aday açık ağırlıklı erişimle kendi donanımında koşar, büyük aday yalnız bir model uç noktası üzerinden çağrılır; kurum sınırını aşan istek sayısı sırasıyla 0, 0 ve 24 olur.
• DL69. Küçük adayın bir düzeneği vardır: biçim denetiminden geçmeyen yanıtlarda isteme iki kurgu örnek eklenip yeniden sorulur. Bu düzenek isabeti yükseltir, çağrı sayısını ve belirteci büyütür.
• DL70. Normalleştirme kuralı tektir: her ölçütte en kötü aday 0, en iyi aday 1 alır, aradaki değer aralığa oranlanır. Ağırlıklar bu normalleştirilmiş sayılara uygulanır.

Üç Aday ve Dört Ölçüt

# ORTAK -- KURGUDUR. Uc aday ayni benzetici uzerinde kurulur; hicbir model ya da
# saglayici anilmaz. Adaylar tanidik obek genisligi, birim carpani ve cikti uzunlugu
# ile ayrilir. Bedel birimi DENK BELIRTEC: belirtec sayisi carpi adayin birim carpani.
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 belirtecle(metin):
    """Kurgu belirtecleyici: harf obekleri dorder, rakam obekleri ikiser bolunur."""
    cikti, tampon = [], ""
    for ch in metin + " ":
        if ch.isalnum():
            tampon += ch
            continue
        if tampon:
            n = 2 if tampon.isdigit() else 4
            cikti += [tampon[i:i + n] for i in range(0, len(tampon), n)]
            tampon = ""
        if ch.strip():
            cikti.append(ch)
    return cikti


BAS = [("sayac okunmadi tahmini fatura cikti", "olcum"),
       ("fatura tutari gecen aya gore iki kat cikti", "odeme"),
       ("gece boyunca su basinci dustu", "tesisat"),
       ("planli kesinti bildirimi ulasmadi", "kesinti"),
       ("abonelik devri sayaca islenmedi", "sozlesme")]
EK = ["sayacin numarasi degistirilmis olabilir", "adres bilgisi eski gorunuyor",
      "onceki ay ayni sorun yasanmadi", "sayaca ulasilamiyor kapi kapali",
      "kesinti suresi beklenenden uzun surdu", "otomatik talimat sayacta yok"]
SOZLUK = {"kesinti": ["kesi", "bild"], "olcum": ["okun", "olcu", "tahm"],
          "tesisat": ["basi", "dust", "tesi", "vana"],
          "odeme": ["fatu", "odem", "tali", "tuta"],
          "sozlesme": ["abon", "adre", "devr", "sozl"]}
SINIFLAR = list(SOZLUK)
TALEP = []
for i in range(24):
    r = uretec(TOHUM + 31 * i)
    a, b = 100000 + int(r() * 380000), 100000 + int(r() * 380000)
    TALEP.append({"no": 4100 + i, "sinif": BAS[i % 5][1],
                  "metin": f"abone {4100 + i}: {BAS[i % 5][0]}, {EK[(5 * i + 2) % 6]}."
                           f" ana sayac {a} ara sayac {b}."})
# (ad, obek genisligi, birim carpani, cikti belirteci, ornek bedeli, disari cikan istek)
ADAY = [("kucuk", 2, 1, 5, 46, 0), ("orta", 3, 4, 7, 0, 0), ("buyuk", 4, 12, 14, 0, 24)]


def cagir(t, genislik, tohum):
    """Benzetici: tanidigi obeklerle etiket secer; ilk iki aday esitse belirsiz doner."""
    bel, sz = belirtecle(t["metin"]), {s: set(o[:genislik]) for s, o in SOZLUK.items()}
    p = sorted(((sum(b in sz[s] for b in bel), s) for s in SINIFLAR), key=lambda x: (-x[0], x[1]))
    if p[0][0] == 0 or p[0][0] == p[1][0]:
        return "belirsiz"
    r = uretec(tohum + 1009 * genislik + 7 * t["no"])
    return p[1][1] if r() < 0.14 else p[0][1]


def olc(aday, tohum=TOHUM):
    ad, g, carpan, cikti, ornek, disari = aday
    dogru = cagri = giris = 0
    for t in TALEP:
        n = len(belirtecle(t["metin"]))
        y, cagri, giris = cagir(t, g, tohum), cagri + 1, giris + n
        if y == "belirsiz" and ornek:           # duzenek: isteme iki ornek eklenip yeniden sorulur
            y, cagri, giris = cagir(t, g + 1, tohum), cagri + 1, giris + n + ornek
        dogru += y == t["sinif"]
    cagri, giris = cagri / 24, giris / 24
    return {"ad": ad, "isabet": dogru / 24, "denk": (giris + cagri * cikti) * carpan,
            "adim": cagri * cikti, "cagri": cagri, "disari": disari}


S = [olc(a) for a in ADAY]
print("aday    isabet  isabet B  denk belirtec  adim  cagri/istek  disari cikan")
for a, s in zip(ADAY, S):
    b = olc(a, TOHUM + 1)["isabet"]
    print(f"{s['ad']:<6}  {s['isabet']:.4f}  {b:.4f}      {s['denk']:>6.1f}    {s['adim']:>5.2f}"
          f"   {s['cagri']:.4f}      {s['disari']:>2}/24")

aday    isabet  isabet B  denk belirtec  adim  cagri/istek  disari cikan
kucuk   0.5000  0.5833        84.5     7.29   1.4583       0/24
orta    0.5833  0.6667       181.2     7.00   1.0000       0/24
buyuk   0.7917  0.7083       627.5    14.00   1.0000      24/24

Dört sütun dört ayrı kazanan gösteriyor. İsabette büyük aday önde: 0,7917. Denk belirteçte küçük aday önde: 84,5, yani büyüğün 627,5’inin yedide birinden az. Adımda orta aday önde, ama farkı incedir: 7,00 karşısında 7,29. Kurum sınırını aşan istekte küçük ve orta aday birlikte önde, çünkü ikisi de kendi donanımında koşuyor.

Küçük adayın adım sayısındaki kaybının nereden geldiği çağrı sütununda yazılı: istek başına 1,4583 çağrı. Bu, düzeneğin bedelidir. Biçim denetiminden geçmeyen yanıtlarda isteme iki örnek eklenip yeniden soruluyor; isabet bu sayede 0,5000’e çıkıyor ama her yeniden sorulan istek bir adım daha ekliyor. Düzenek isabeti alıp gecikmeyi veriyor, ve iki sayı da tabloda yan yana duruyor.

Denk belirteç biriminin ne olduğuna dikkat etmek gerekir. Üç aday aynı isteği alıyor ve neredeyse aynı sayıda belirteç okuyor; ham belirteç sayısıyla bakıldığında üçü de birbirine yakındır. Fark belirtecin sayısında değil tuttuğunda: aynı belirteci işlemek büyük adayda küçük adayın on iki katı hesap yükü demektir. Birim çarpanı bu yükü tek bir sayıya indiriyor ve karşılaştırmayı mümkün kılıyor. Para birimi yazılmamasının nedeni de budur: çarpan yapısaldır ve beş yıl sonra da aynı biçimde okunur, bir fiyat listesi ise okunmaz. Çıktı belirteci ayrıca sayılır, çünkü çıktı sıralı üretilir ve hem bedele hem adıma girer; büyük adayın 14 belirteçlik yanıtı, aynı yanıtı 5 belirteçte veren küçük adaya göre iki kat gecikme demektir.

Ağırlık Değişince Kazanan Değişiyor

OLCUT = [("isabet", "isabet", 1), ("denk belirtec", "denk", -1), ("adim", "adim", -1),
         ("disari cikan istek", "disari", -1)]


def normal(sonuc, anahtar, yon):
    """Tek normallestirme kurali: aralikta en kotu 0, en iyi 1."""
    v = [s[anahtar] for s in sonuc]
    lo, hi = min(v), max(v)
    if hi == lo:
        return [1.0] * len(v)
    return [((x - lo) if yon > 0 else (hi - x)) / (hi - lo) for x in v]


N = {a: normal(S, a, y) for _, a, y in OLCUT}
AGIRLIK = [("dengeli", (1, 1, 1, 1)), ("isabet agirlikli", (4, 1, 1, 1)),
           ("bedel agirlikli", (1, 4, 1, 1)), ("gecikme agirlikli", (1, 1, 4, 1)),
           ("veri siniri agirlikli", (1, 1, 1, 4))]
print("olcut               kucuk   orta   buyuk")
for ad, a, _ in OLCUT:
    print(f"{ad:<18}  {N[a][0]:.4f}  {N[a][1]:.4f}  {N[a][2]:.4f}")
print("agirlik seti            kucuk   orta   buyuk   kazanan")
for ad, w in AGIRLIK:
    p = [sum(w[j] * N[a][i] for j, (_, a, _) in enumerate(OLCUT)) for i in range(3)]
    print(f"{ad:<22}  {p[0]:.4f}  {p[1]:.4f}  {p[2]:.4f}  {S[p.index(max(p))]['ad']}")

olcut               kucuk   orta   buyuk
isabet              0.0000  0.2857  1.0000
denk belirtec       1.0000  0.8220  0.0000
adim                0.9583  1.0000  0.0000
disari cikan istek  1.0000  1.0000  0.0000
agirlik seti            kucuk   orta   buyuk   kazanan
dengeli                 2.9583  3.1078  1.0000  orta
isabet agirlikli        2.9583  3.9649  4.0000  buyuk
bedel agirlikli         5.9583  5.5739  1.0000  kucuk
gecikme agirlikli       5.8333  6.1078  1.0000  orta
veri siniri agirlikli   5.9583  6.1078  1.0000  orta

Beş ağırlık setinde üç ayrı kazanan çıkıyor. Eşit ağırlıkta orta aday kazanıyor ve farkı küçüktür: 3,1078 karşısında 2,9583. İsabet ağırlığı dörde çıkınca büyük aday öne geçiyor, ama yine kılpayı: 4,0000 karşısında 3,9649. Bedel ağırlığı dörde çıkınca küçük aday kazanıyor. Gecikme ve veri sınırı ağırlıkları ortayı büyütmekten başka bir şey yapmıyor.

Aynı üç aday, aynı dört sayı, üç ayrı karar. Değişen tek şey hangi ölçütün ne kadar saydığıdır. Bu yüzden “hangi model daha iyi” sorusunun ölçüsü yoktur; ölçüsü olan soru “bu dört sayı ve şu ağırlıklarla hangi aday kazanıyor” sorusudur. Bir seçim gerekçesi, ağırlığını yazmadığı sürece bir gerekçe değil bir tercihtir.

Normalleştirme kuralının kendisi de bir karardır ve tabloda görünmez. Burada kullanılan kural aralığa oranlıyor: her ölçütte en kötü aday 0, en iyi aday 1 alıyor. Bu kural, aradaki farkın ne kadar büyük olduğuna bakmaz — isabette küçük ile orta arasındaki 0,0833’lük fark, aralığın 0,2917’lik genişliğine bölünüp 0,2857’ye çıkıyor, yani küçük bir mutlak fark büyük bir normalleştirilmiş farka dönüşüyor. Başka bir kural başka sayılar verirdi. Ortam Seçimi dersi bunun seçimi çevirebildiğini ölçtüğü için burada tek kural kullanılıyor ve kullanıldığı yazılıyor; yazılmadığında tablo, olmadığı kadar nesnel görünür.

Eşik ve Seçimin Kendi Belirsizliği

def kazanan(N, w):
    p = [sum(w[j] * N[a][i] for j, (_, a, _) in enumerate(OLCUT)) for i in range(3)]
    return ADAY[p.index(max(p))][0]


print("taranan olcut       agirlik 1  ilk degisim  yeni kazanan")
for j, (ad, _, _) in enumerate(OLCUT):
    onceki, esik, yeni = kazanan(N, (1, 1, 1, 1)), "-", "-"
    for w in range(2, 13):
        k = kazanan(N, tuple(w if i == j else 1 for i in range(4)))
        if k != onceki and esik == "-":
            esik, yeni = w, k
    print(f"{ad:<18}  {onceki:<9}  {str(esik):<11}  {yeni}")
S2 = [olc(a, TOHUM + 1) for a in ADAY]
N2 = {a: normal(S2, a, y) for _, a, y in OLCUT}
print("agirlik seti            tohum 20260218  tohum 20260219")
for ad, w in AGIRLIK:
    print(f"{ad:<22}  {kazanan(N, w):<14}  {kazanan(N2, w)}")

taranan olcut       agirlik 1  ilk degisim  yeni kazanan
isabet              orta       4            buyuk
denk belirtec       orta       2            kucuk
adim                orta       -            -
disari cikan istek  orta       -            -
agirlik seti            tohum 20260218  tohum 20260219
dengeli                 orta            orta
isabet agirlikli        buyuk           orta
bedel agirlikli         kucuk           kucuk
gecikme agirlikli       orta            orta
veri siniri agirlikli   orta            orta

Eşikler asimetriktir. Bedel ağırlığı 2 olduğunda seçim ortadan küçüğe geçiyor; isabet ağırlığı ise 4’e çıkmadan büyüğü öne getirmiyor. Gecikme ve veri sınırı ağırlıkları on ikiye kadar taransa da seçimi değiştirmiyor, çünkü bu iki ölçütte kazanan zaten ortadır ve ağırlık artırmak kazananı pekiştirmekten başka bir şey yapmaz. Bir ölçütün ağırlığını büyütmek, o ölçütte önde olmayan bir adayı asla öne getirmez.

Son tablo bu dersin en rahatsız edici sayısıdır. Aynı hesap tohum 20260219 ile tekrarlandığında isabet ağırlıklı setin kazananı büyükten ortaya dönüyor. Hiçbir ölçüt değişmedi, hiçbir ağırlık değişmedi; yalnız benzeticinin örnekleme tohumu değişti ve büyük adayın isabeti 0,7917’den 0,7083’e indi. Kılpayı kazanılan bir karar, koşumdan koşuma değişen bir bileşenin üstüne kurulduğunda kendisi de koşuma bağlı olur. Dört ölçütün üçünde seçim sağlamdır; dördüncüsünde değildir ve bu, tek koşumla ölçen bir karşılaştırmanın hiç göremeyeceği bir şeydir.

Buradan pratik bir kural çıkıyor. Bir seçim tablosu yalnız kazananı değil, kazanma payını da yazmalıdır. Payı geniş olan satırlar, ağırlıklar biraz oynasa ya da ölçüm biraz kaysa da ayakta kalır; payı ince olanlar kalmaz. Eşit ağırlıktaki 3,1078 ile 2,9583 arasındaki 0,1495’lik pay ile isabet ağırlıklı setteki 4,0000 ile 3,9649 arasındaki 0,0351’lik pay aynı tabloda durur ama aynı şeyi söylemez. İnce paylı bir satırda doğru davranış, kazananı ilan etmek değil, iki adayı da ölçüyü büyüterek yeniden koşturmak ya da kararı bir ölçüte daha bağlamaktır.

Özet

• Üç aday dört ölçütte sayılınca kazanan dörde bölünüyor: isabette büyük 0,7917, denk belirteçte küçük 84,5, adımda orta 7,00, kurum sınırını aşan istekte küçük ve orta 0/24.
• Küçük adayın düzeneği isabeti 0,5000’e çıkarırken çağrı sayısını 1,4583’e ve adımı 7,29’a taşıyor; kazanç ile bedel aynı tabloda durur.
• Beş ağırlık setinde kazanan üç kez orta, bir kez büyük, bir kez küçük çıkıyor; eşit ağırlıkta fark 3,1078 karşısında 2,9583 gibi incedir.
• Eşikler asimetriktir: bedel ağırlığı 2’de seçimi ortadan küçüğe, isabet ağırlığı 4’te ortadan büyüğe çevirir; gecikme ve veri sınırı ağırlıkları on ikiye kadar seçimi değiştirmez.
• Tohum 20260219 ile isabet ağırlıklı setin kazananı büyükten ortaya dönüyor; kılpayı verilen bir seçim koşuma bağlı hale gelir.

Sonraki Adım

Bu derste bedel bir ölçüt olarak sayıldı, ama bir sınır olarak hiç kullanılmadı. Kazanan aday her ağırlık setinde serbestçe seçildi; oysa gerçek bir sistemde belirteç bütçesi bir üst sınırdır ve seçimi değil tasarımı dayatır. Aynı görev, aynı model ve aynı isabetle bile, istemin nasıl yazıldığına göre istek başına kaç belirteç harcandığı büyük ölçüde değişir. Sonraki ders dört düzeneği belirteç ve isabet olarak karşılaştırır — uzun istem, kısa istem ile örnek, özetleyip gönderme ve önbellek — ve bütçe daraldığında hangi tasarımın zorunlu hale geldiğini gösterir. O ders aynı zamanda kursun kapanışıdır.