---
title: 'Ürün Geliştirmeye Etkisi'
source: 'https://academia.sh/tr/kurslar/yz-muhendisligine-giris/urun-gelistirmeye-etkisi'
course: 'Yapay Zekâ Mühendisliğine Giriş'
language: tr
updated: '2026-08-17T18:06:36+00:00'
license: 'CC BY-SA 4.0'
---

# Ürün Geliştirmeye Etkisi

Belirsiz çıktıyla ürün tasarlamanın sayıyla ölçülmesi: aynı 72 kurgu destek talebi iki koşumda çağrıldığında yalın istemde yanıt metni kayıtların 0,7639 payında, altındaki karar ise 0,5000 payında değişiyor ve kayıtların 0,4167 payında doğru yanıt yalnız bir koşumda çıkıyor. Belirsizliği daraltan üç tasarım kararı yan yana ölçülüyor: biçim dayatmak görünen değişimi 0,7500'den 0,3889'a indiriyor, kaynağa bağlamak 0,0833'e indirip isabeti 0,8958'e çıkarıyor ve 144 erişim adımı ekliyor, seçenek sunmak ise değişimi 0,4583'e yükseltip çağrıyı iki katına çıkarıyor.

Önceki ders tohum satırını tek bir sayıyla gösterdi: toplam isabet 0,8056'dan 0,6806'ya indi. O
satır bir ürünün en zor tasarım sorusudur ve toplam sayı onu gizler. Aynı kullanıcı, aynı ekranda,
aynı metni iki kez gönderdiğinde iki ayrı yanıt alabilir. Toplam isabetin aynı kalması bile bunu
gizler, çünkü bir kayıtta kazanılan doğru yanıt başka bir kayıtta kaybedilmiş olabilir.

Bu ders belirsizliği kayıt düzeyinde sayar ve iki soruyu ayırır: **çıktının kaç kayıtta değiştiği**
ve **bu değişimin kullanıcıya görünen kısmının ne olduğu**. Ardından belirsizliği daraltan üç
tasarım kararı aynı ölçüde karşılaştırılır.

- **YA16.** Kurgu, benzetici ve sınama kümesi önceki dersten aynen sürer: 72 kayıt, beş konu,
  tohum **20260218**. İkinci koşum **20260219** tohumuyla alınır.
- **YA17.** İki koşum arasında karşılaştırılan şey **ürünün gösterdiği çıktıdır**. Yalın istemde
  bu bir cümledir, yönergeli istemde tek bir etikettir; ikisi ayrı ayrı sayılır.
- **YA18.** Kurgu belge dağarcığı on kayıttır: tarife açıklamaları, sayaç bakım yordamları ve
  arıza kodları. Belge kodları da kurgudur.
- **YA19.** Erişim, talebin belirteçleriyle en çok örtüşen belgeyi seçer. Bir **adımdır**, model
  çağrısı değildir; bedel tablosunda ayrı sütunda sayılır.
- **YA20.** Seçenek sunmanın isabeti **başka bir ölçütle** okunur: doğru etiketin iki adaydan
  birinde bulunması yeter. Öbür üç satırla aynı sütunda durur ama aynı şeyi ölçmez.
- **YA21.** Görünen değişim **düşük olduğunda iyidir**; isabet yüksek olduğunda. İki sütunun yönü
  terstir ve tabloda birlikte okunur.
- **YA22.** Hız sınırına takılan çağrılar her ölçümün başında sayaç sıfırlandığı için iki koşumda
  aynı yerlere düşer; değişim sayısı bu yüzden yalnız modelin belirsizliğinden gelir.

## Aynı Girdinin İki Koşumu

İlk blok benzeticiyi kurar ve her talebi iki tohumla çağırıp dört sayıyı ayırır: metin değişti mi,
karar değişti mi, iki koşumda da doğru mu, yalnız birinde mi doğru.

```python
# BENZETICI. Bu kod gercek bir model uc noktasi cagirmaz; standart kitaplikla yazilmis
# bir dil modeli benzeticisidir. Destek talepleri de KURGU'dur.
import math

TOHUM, M32 = 20260218, 0xFFFFFFFF
PENCERE, EN_UZUN = 240, 24


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):
    b = []
    for s in m.lower().replace(",", " , ").split():
        while len(s) > 5:
            b.append(s[:5])
            s = s[5:]
        b.append(s)
    return b


def izno(m):
    h = 2166136261
    for c in m:
        h = ((h ^ ord(c)) * 16777619) & M32
    return h


KONU = ["fatura", "ariza", "sayac", "tarife", "kesinti"]
KALIP = {
    "fatura": ["bu ayki fatura tutari gecen aya gore cok yuksek geldi",
               "faturami odedim ama sistemde borc gorunuyor",
               "fatura ayrintisini nereden gorebilirim"],
    "ariza": ["evde su akmiyor bir ariza var galiba",
              "baglanti bozuk oldu ve hic calismiyor",
              "ariza kaydi actim ama ekip gelmedi"],
    "sayac": ["sayac okumasi yanlis girilmis endeks tutmuyor",
              "sayac degisimi icin randevu istiyorum",
              "sayac uzerindeki endeks ile fatura ayni degil"],
    "tarife": ["hangi tarife basamagindayim ogrenmek istiyorum",
               "tarife degisikligi icin ne yapmam gerekiyor",
               "birim ucret abone tipine gore degisiyor mu"],
    "kesinti": ["mahallede kesinti var ne zaman gelecek",
                "planli kesinti duyurusu nereden takip edilir",
                "aksamdan beri kesinti yasiyoruz"],
}
EK = ["ayrica gecen ay da ayni sorun olmustu", "bu konuda memnun degilim",
      "acil bilgi almam gerekiyor", "kayit numaram elimde yok"]

TALEP = []
for i in range(120):
    r = uretec(TOHUM + i)
    k = KONU[ayrik(r(), [0.24, 0.22, 0.18, 0.20, 0.16])]
    m = KALIP[k][int(r() * 3)]
    if r() < 0.34:
        m += " " + EK[int(r() * 4)]
    TALEP.append({"no": 4001 + i, "metin": m, "konu": k})

KAVRAM = KONU + ["odeme", "sikayet", "bilgi", "genel"]
IZ = {"fatur": "fatura", "tutar": "fatura", "ayrin": "fatura",
      "ariza": "ariza", "bozuk": "ariza", "calis": "ariza", "akmiy": "ariza",
      "sayac": "sayac", "endek": "sayac", "okuma": "sayac",
      "tarif": "tarife", "birim": "tarife", "abone": "tarife", "basam": "tarife",
      "kesin": "kesinti", "duyur": "kesinti", "mahal": "kesinti",
      "borc": "odeme", "odedi": "odeme", "ucret": "odeme",
      "memnu": "sikayet", "sorun": "sikayet", "acil": "sikayet",
      "bilgi": "bilgi", "ogren": "bilgi", "nered": "bilgi"}
TUZAK = {"degis": "tarife", "kayit": "ariza", "yukse": "tarife", "gorun": "fatura",
         "ekip": "kesinti", "takip": "tarife", "giril": "fatura"}
SERBEST = ["talebiniz {k} konusuyla ilgili gorunuyor",
           "bu kayit {k} basligina girer , ilgili ekibe yonlendirildi",
           "kaydiniz alindi , konuyu inceleyip donus yapacagiz"]
SAYAC = [0]


def cagir(istem, tohum=TOHUM, sicaklik=0.6, en_uzun=EN_UZUN):
    SAYAC[0] += 1
    bel = belirtecle(istem)
    if len(bel) > PENCERE:
        return {"durum": "baglam_asimi", "giris": len(bel), "cikis": 0, "yanit": ""}
    if SAYAC[0] % 37 == 0:
        return {"durum": "hiz_siniri", "giris": len(bel), "cikis": 0, "yanit": ""}
    r = uretec(tohum ^ izno(istem))
    if len(bel) > 90 and r() < 0.04:
        return {"durum": "zaman_asimi", "giris": len(bel), "cikis": 0, "yanit": ""}
    aday = [k for k in KAVRAM if k[:5] in bel]
    if len(aday) < 3:
        aday = KAVRAM
    p = {k: 0.15 for k in aday}
    for t in bel:
        for tablo, w in ((IZ, 1.0), (TUZAK, 1.3)):
            if tablo.get(t) in p:
                p[tablo[t]] += w
    if sicaklik <= 0.0:
        k = max(sorted(p), key=lambda a: p[a])
    else:
        e = [math.exp(p[a] / sicaklik) for a in sorted(p)]
        k = sorted(p)[ayrik(r(), [v / sum(e) for v in e])]
    y = k if "tek" in bel else SERBEST[ayrik(r(), [0.42, 0.26, 0.32])].format(k=k)
    cb = belirtecle(y)
    if len(cb) > en_uzun:
        cb = cb[:en_uzun]
        y = " ".join(cb)
    return {"durum": "tamam", "giris": len(bel), "cikis": len(cb), "yanit": y}


def oku(y):
    for s in y.lower().split():
        if s in KONU:
            return s
    return None


SIN = TALEP[48:]
YALIN = "Su destek talebini yanitla: "
YONERGE = ("Talebi su etiketlerden birine ata: fatura , ariza , sayac , tarife , "
           "kesinti . Yanit olarak tek etiket yaz . Talep: ")


def iki_kosum(onek):
    SAYAC[0] = 0
    metin = karar = ikisi = biri = hicbiri = 0
    for x in SIN:
        a = cagir(onek + x["metin"], tohum=TOHUM)
        b = cagir(onek + x["metin"], tohum=TOHUM + 1)
        ea, eb = oku(a["yanit"]), oku(b["yanit"])
        metin += a["yanit"] != b["yanit"]
        karar += ea != eb
        d = (ea == x["konu"]) + (eb == x["konu"])
        ikisi += d == 2
        biri += d == 1
        hicbiri += d == 0
    n = len(SIN)
    return metin / n, karar / n, ikisi / n, biri / n, hicbiri / n


print(f"{'istem':<10} {'metin degisti':>14} {'karar degisti':>14} {'ikisi dogru':>12} "
      f"{'yalniz biri':>12} {'ikisi yanlis':>13}")
for ad, o in (("yalin", YALIN), ("yonergeli", YONERGE)):
    m, k, i2, b1, h = iki_kosum(o)
    print(f"{ad:<10} {m:>14.4f} {k:>14.4f} {i2:>12.4f} {b1:>12.4f} {h:>13.4f}")
```

```
istem       metin degisti  karar degisti  ikisi dogru  yalniz biri  ikisi yanlis
yalin              0.7639         0.5000       0.3333       0.4167        0.2500
yonergeli          0.4167         0.4167       0.5417       0.3750        0.0833
```

İlk satırda iki sütun arasındaki fark dersin ana bulgusudur. Yalın istemde **yanıt metni kayıtların
0,7639 payında değişiyor**, ama altındaki **karar yalnız 0,5000 payında** değişiyor. Aradaki
0,2639, kararın aynı kaldığı hâlde cümlenin başka kurulduğu kayıtlardır. Kullanıcının gördüğü şey
cümleyse ürün iki kat kararsız görünür; gördüğü şey karar ise gerçek kararsızlık okunur. **Bir
ürünün belirsizliği, modelin belirsizliği değil, ekrana koyduğu şeyin belirsizliğidir.**

Dördüncü sütun ise ürün açısından en pahalı sayıdır. Yalın istemde kayıtların **0,4167 payında**
doğru yanıt yalnız bir koşumda çıkıyor. Bu kayıtlarda kullanıcının doğru yanıt alıp almaması,
görebildiği ya da değiştirebildiği hiçbir şeye bağlı değildir. Yönergeli istemde bu pay 0,3750'ye
iniyor ve "iki koşumda da yanlış" payı 0,2500'den 0,0833'e düşüyor: yönerge doğruların sayısını
artırmakla kalmıyor, **kalıcı yanlışları** da azaltıyor.

Bu iki satırın ürün tasarımına üç doğrudan sonucu vardır. Birincisi, aynı talebin iki kez
gönderilmesi bir hata değil beklenen davranıştır; yanıtı saklamak ve ikinci istekte saklanan yanıtı
göstermek, isabeti hiç değiştirmeden görünen kararsızlığı sıfıra indirir. İkincisi, "yalnız birinde
doğru" payı destek kaydına yazılmalıdır: bir yanlış yanıtın kalıcı mı yoksa koşuma bağlı mı olduğu
ancak iki koşum saklanırsa ayırt edilir. Üçüncüsü, kullanıcıya gösterilen metnin serbest bırakılması
bedava değildir; aynı kararı taşıyan iki ayrı cümle, kullanıcıya iki ayrı yanıt olarak görünür ve
şikâyet sayısını kararın kendisinden bağımsız olarak büyütür.

## Belirsizliği Daraltan Üç Tasarım Kararı

Üç karar aynı ölçüde karşılaştırılır: seçenek sunmak, biçim dayatmak, kaynağa bağlamak. Kaynağa
bağlama için kurgu bir belge dağarcığı kurulur ve talebe en çok örtüşen belge isteme eklenir.

```python
BELGE = [("TR-11", "tarife basamagi abone tipine ve birim ucrete gore belirlenir"),
         ("TR-12", "tarife degisikligi basvurusu her donem basinda alinir"),
         ("FT-21", "fatura tutari donem okumasi uzerinden hesaplanir , ayrinti ekranda"),
         ("FT-22", "odeme sonrasi borc kaydi ayni gun kapanir"),
         ("SY-31", "sayac endeks okumasi her donem alinir ve tutanaga gecer"),
         ("SY-32", "sayac degisimi randevu ile yapilir , eski endeks tutanakta kalir"),
         ("AR-41", "ariza kaydi acildiginda saha ekibi yonlendirilir"),
         ("AR-42", "bozuk baglanti icin once hat kontrolu yapilir"),
         ("KS-51", "planli kesinti duyurusu once yayimlanir"),
         ("KS-52", "mahalle bazinda kesinti takibi harita uzerinden yapilir")]


def eris(metin):                        # ERISIM adimi: en cok parca ortusen belge
    b = set(belirtecle(metin))
    return max(BELGE, key=lambda d: (len(b & set(belirtecle(d[1]))), d[0]))


def kur(tasarim, x, tohum):             # istemler ve erisim adimi sayisi
    if tasarim == "serbest":
        return [(YALIN + x["metin"], tohum)], 0
    if tasarim == "secenek":
        return [(YONERGE + x["metin"], tohum + j) for j in (0, 2)], 0
    if tasarim == "bicim":
        return [(YONERGE + x["metin"], tohum)], 0
    k, m = eris(x["metin"])
    return [(YONERGE + "Belge " + k + ": " + m + " . Talep: " + x["metin"], tohum)], 1


def kosum(tasarim, tohum):
    SAYAC[0] = 0
    gor, dogru, bel, adim = [], 0, 0, 0
    for x in SIN:
        istem, a = kur(tasarim, x, tohum)
        adim, e, son = adim + a, [], ""
        for i, th in istem:
            s = cagir(i, tohum=th)
            bel += s["giris"] + s["cikis"]
            e.append(oku(s["yanit"]))
            son = s["yanit"]
        ad = sorted(set(e) - {None})
        gor.append(" ".join(ad) if tasarim == "secenek" else son)
        dogru += (x["konu"] in ad) if tasarim == "secenek" else (e[0] == x["konu"])
    return gor, dogru / len(SIN), SAYAC[0], bel, adim


print(f"{'tasarim karari':<18} {'degisim':>8} {'isabet':>8} {'cagri':>6} "
      f"{'belirtec':>9} {'erisim':>7}")
for ad, t in (("duzeneksiz", "serbest"), ("bicim dayatmak", "bicim"),
              ("secenek sunmak", "secenek"), ("kaynaga baglamak", "kaynak")):
    g1, i1, c1, b1, a1 = kosum(t, TOHUM)
    g2, i2, c2, b2, a2 = kosum(t, TOHUM + 1)
    dg = sum(u != v for u, v in zip(g1, g2)) / len(g1)
    print(f"{ad:<18} {dg:>8.4f} {(i1 + i2) / 2:>8.4f} {c1 + c2:>6d} {b1 + b2:>9d} "
          f"{a1 + a2:>7d}")
```

```
tasarim karari      degisim   isabet  cagri  belirtec  erisim
duzeneksiz           0.7500   0.5556    144      4473       0
bicim dayatmak       0.3889   0.7431    144      6674       0
secenek sunmak       0.4583   0.9306    288     13341       0
kaynaga baglamak     0.0833   0.8958    144      9459     144
```

**Biçim dayatmak** en ucuz karardır: görünen değişimi 0,7500'den **0,3889'a** indiriyor, isabeti
0,5556'dan **0,7431'e** çıkarıyor ve çağrı sayısına hiç dokunmuyor. Bedeli yalnız 2201 belirteçtir
ve bunun tamamı isteme yazılan yönergeden gelir.

**Kaynağa bağlamak** en güçlü karardır: görünen değişim **0,0833'e** iniyor, yani kayıtların
yalnız altı tanesinde iki koşum ayrışıyor. İsabet **0,8958**. Bunun nedeni belgenin isteme
girmesiyle doğru konunun kanıtının ağır basması, yani kararın örneklemeye daha az kalmasıdır.
Bedeli iki kalemdir: biçim dayatmaya göre 2785 fazla belirteç ve **144 erişim adımı**. Erişim bir
model çağrısı değildir ama bir gecikme kaynağıdır ve kendi hatasını taşır — yanlış belge geldiğinde
model **kararlı biçimde yanlış** yanıt verir.

**Seçenek sunmak** bu tabloda müfredatın ikinci iddiasını ödeyen satırdır. İsabet sütununda en
yüksek sayı onda: 0,9306. Ama o sayı başka bir ölçüttür — doğru etiketin iki adaydan birinde
bulunması yeter ve seçme işi kullanıcıya bırakılır. Kendi ölçütünde, yani **görünen değişimde**,
seçenek sunmak biçim dayatmayı **geriye götürüyor**: 0,3889'dan 0,4583'e. İki adaydan biri
değiştiğinde ekrandaki kutu da değişir, dolayısıyla iki koşum arasında daha çok kayıtta ayrışma
olur. Karşılığında çağrı sayısı **iki katına**, belirteç iki katına çıkıyor. **Eklenen düzenek
sayıyı düşürdü ve bedeli kesin biçimde arttı.**

## Özet

- Yalın istemde yanıt metni kayıtların **0,7639** payında, altındaki karar ise **0,5000** payında
  değişiyor. Aradaki fark, ürünün ekrana ne koyduğuna göre kararsızlığın iki katı görünmesidir.
- Kayıtların **0,4167** payında doğru yanıt yalnız bir koşumda çıkıyor. Bu pay kullanıcının
  göremediği ve etkileyemediği bir kayıptır; yönergeli istemde 0,3750'ye, kalıcı yanlış payı
  0,2500'den **0,0833'e** iniyor.
- Biçim dayatmak görünen değişimi **0,7500'den 0,3889'a**, isabeti **0,5556'dan 0,7431'e** taşıyor
  ve çağrı sayısını hiç değiştirmiyor; bedeli 2201 belirteçtir.
- Kaynağa bağlamak değişimi **0,0833'e** indirip isabeti **0,8958** yapıyor; bedeli 2785 fazla
  belirteç ve **144 erişim adımıdır**. Yanlış belge geldiğinde yanlış yanıt kararlı hâle gelir.
- Seçenek sunmak görünen değişimi **0,3889'dan 0,4583'e yükseltiyor** ve çağrıyı iki katına
  çıkarıyor; isabet sütunundaki 0,9306 başka bir ölçüttür ve seçme işini kullanıcıya devreder.
- Gecikme sınıfı da ayrışıyor: düzeneksiz ve biçim dayatan yollar **tek çağrıdır**, kaynağa
  bağlamak **erişim ve çağrı zinciridir**, seçenek sunmak **iki paralel çağrıdır**. Dört satır tek
  bir kuralla okunur: bir tasarım kararı ancak **kendi ölçütünde** ve **bedeliyle** yazıldığında
  karşılaştırılabilir.

## Sonraki Adım

Üç derste model verilmiş bir bileşen olarak ele alındı, yüzeyinden ölçüldü, ayarları sayıldı ve
belirsizliği ürün diline çevrildi. Bu üç ders boyunca kullanılan sözcükler de bir tasarım
nesnesidir. "Yetenek", "anlıyor", "öğreniyor", "genel zekâ" gibi ifadeler aynı tabloya
yazılamayacak kadar farklı şeylerdir: bir kısmı bir sınamaya bağlanabilir ve bir sayı verir, bir
kısmı hiçbir koşulda yanlışlanamaz. Sonraki ders bir dizi cümleyi bu ölçüte göre ayırır ve kaçının
gerçekten bir sınamaya bağlanabildiğini sayar.
