---
title: 'Model Seçimi'
source: 'https://academia.sh/tr/kurslar/yz-muhendisligine-giris/model-secimi'
course: 'Yapay Zekâ Mühendisliğine Giriş'
language: tr
updated: '2026-08-17T18:06:36+00:00'
license: 'CC BY-SA 4.0'
---

# Model Seçimi

Üç aday benzetici düzeyinde kurulup dört ölçütte sayılıyor: küçük yetenek 0,5000 isabet / 84,5 denk belirteç / 7,29 adım / 0 istek dışarı, orta yetenek 0,5833 / 181,2 / 7,00 / 0, büyük yetenek 0,7917 / 627,5 / 14,00 / 24. Beş ağırlık setinde kazanan üç kez orta, bir kez büyük, bir kez küçük çıkıyor. Ağırlık taraması eşikleri veriyor: isabet ağırlığı 4 olduğunda seçim ortadan büyüğe, bedel ağırlığı 2 olduğunda ortadan küçüğe geçiyor, gecikme ve veri sınırı ağırlıkları on ikiye kadar seçimi değiştirmiyor. Tohum 20260219 ile aynı hesap tekrarlandığında isabet ağırlıklı setin kazananı büyükten ortaya dönüyor.

Ö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

```python
# 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

```python
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

```python
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.
