``

Önce problemi doğru tarif edelim

Kaynak optimizasyonunun temelinde yöneylem araştırması bulunur. Sistem; karar değişkenlerini, kısıtları ve hedefleri matematiksel bir modele dönüştürür. Örneğin karar, uygun bir elektif yatışın belirli bir güne planlanıp planlanmayacağı olabilir. Kısıtlar ise kullanılabilir yatakları, bakım saatlerini ve cihaz kapasitesini temsil eder.

Ancak kaynaklar birbirinin yerine geçmez. Boş bir servis yatağı, yoğun bakım yatağının alternatifi değildir; müsait bir çalışan da her uzmanlık görevini üstlenemez. Bu nedenle toplam kapasiteden önce klinik uygunluk ve yetkinlik kontrol edilir.

Matematik: Kapasiteyi aşmadan değer üretmek

Basitleştirilmiş bir günlük modelde $x_i$, aday yatış planlanırsa $1$, aksi durumda $0$ olsun. $u_i$ klinik ekipçe belirlenen öncelik puanını, $a_{ir}$ adayın kaynak tüketimini, $C_r$ ise kapasiteyi göstersin:

Bu yapı, çok boyutlu sırt çantası problemine benzer: Çantamız hastane, bölmeleri ise kaynaklardır. Gerçek modeller ayrıca bekleme süresi, fazla mesai ve iş yükü dengesizliğini ele alır. Bu hedeflerin ağırlıkları gelişigüzel seçilmemeli; klinik yönetişimle belirlenmelidir. Güvenlik şartları, birkaç puan uğruna esnetilen tercihler değil, zorunlu kısıtlardır.

Hangi algoritma, hangi iş için?

Önceliği en yüksek hastayı sırayla yerleştirmek caziptir. Fakat bu hasta kıt bir cihazın çoğunu kullanıyorsa, başka uygun kombinasyonlar toplamda daha iyi sonuç verebilir. Optimizasyonun farkı, kararları tek tek değil, birbirleriyle etkileşimleri içinde değerlendirmesidir.

Python ile küçük bir planlama modeli

Aşağıdaki örnek, OR-Tools üzerinden günlük elektif yatış adaylarını seçer. Kurulum için pip install ortools kullanılabilir. Her satır sırasıyla yatak, hemşirelik saati, cihaz saati ve öncelik puanı içerir; değerler tamamen örnektir.

from ortools.sat.python import cp_model

adaylar = [(1, 8, 6, 9), (1, 10, 8, 8),
           (1, 6, 4, 6), (1, 4, 0, 4)]
kapasiteler = [3, 24, 16]

model = cp_model.CpModel()
x = [model.new_bool_var(f"aday_{i}")
     for i in range(len(adaylar))]

for r, kapasite in enumerate(kapasiteler):
    model.add(sum(adaylar[i][r] * x[i]
                  for i in range(len(adaylar))) <= kapasite)

model.maximize(sum(adaylar[i][3] * x[i]
                   for i in range(len(adaylar))))

solver = cp_model.CpSolver()
solver.parameters.max_time_in_seconds = 2.0
sonuc = solver.solve(model)

if sonuc in (cp_model.OPTIMAL, cp_model.FEASIBLE):
    print([i for i in range(len(adaylar)) if solver.value(x[i])])
else:
    print("Süre içinde uygulanabilir plan bulunamadı.")

Bu veride en iyi seçim, sıfırdan başlayan indekslerle [0, 1, 3] olur. Toplam tüketim üç yatak, 22 hemşirelik saati ve 14 cihaz saatidir. FEASIBLE, uygulanabilir çözüm bulunduğunu söyler; OPTIMAL ise en iyiliğin kanıtlandığını belirtir.

Önemli ayrıntı: Günlük saat toplamı, aynı anda yeterli personel veya cihaz bulunduğunu garanti etmez. Gerçek çizelgelemede zaman aralıkları tanımlanır; NoOverlap tek cihazdaki çakışmaları, Cumulative eşzamanlı kapasite kullanımını sınırlar. Personel yetkinliği ve hasta bakım oranları ayrıca modellenir.

Planı yaşayan bir sisteme dönüştürmek

Acil başvurular, geciken taburculuklar ve cihaz arızaları planı değiştirir. Bu yüzden tahminler senaryolarla sınanmalı, beklenmedik talep için kapasite tamponu bırakılmalı ve plan düzenli güncellenmelidir. Her değişimde tüm vardiyayı dağıtmak yerine, mevcut plana sadakati gözeten cezalar kullanılabilir.

Başarıyı yalnızca yatak doluluğuyla ölçmeyin: Bekleme süresi, fazla mesai, iptaller, bakım güvenliği ve çalışan yükü birlikte izlenmelidir. Sistem karar desteğidir; acil bakımın reddini otomatikleştirmez. Klinik onay, insan müdahalesi, erişim kontrolü ve denetlenebilir karar kayıtları korunmalıdır. İyi algoritma, hastaneyi bir elektronik tabloya değil, daha uyumlu çalışan bir ekibe dönüştürür.

Battle Royale oyunlarında asıl rakibiniz bazen karşınızdaki oyuncu değil, arkanızdan yaklaşan çemberdir. Daralan harita, devasa bir oyun alanını giderek küçülen bir karar kutusuna dönüştürür. Oyuncuya görünmez bir yönetmen gibi seslenir: “Eşyalarını topladın mı? Güzel, şimdi biraz hareket zamanı!” Peki bu basit geometrik fikir, davranışları nasıl bu kadar güçlü biçimde şekillendiriyor?

``

Büyük Haritadan Ortak Finale

PUBG ve Fortnite gibi oyunların popülerleşmesini yalnızca daralan haritaya bağlamak eksik olur. Erişilebilirlik, sosyal oyun deneyimi ve yayın kültürü de önemli etkenlerdir. Ancak güvenli bölge, bu türün seyir zevkini ve maç ritmini taşıyan temel mekaniklerden biridir.

Başlangıçta oyuncular farklı noktalara dağılır; keşif, ekipman toplama ve çatışmadan kaçınma mümkündür. Bölge daraldıkça bu özgürlük azalır. Böylece birbirinden bağımsız küçük hikâyeler, ortak bir final sahnesinde birleşir. Tasarımcı her karşılaşmayı senaryolaştırmadan gerilimi artırabilir.

Teorik Temel: Alan Azalınca Ne Değişir?

Dairesel güvenli bölgenin alanı $A(t)=πr(t)^2$ olarak ifade edilir. Burada $r(t)$, zamana bağlı yarıçaptır. Yarıçap yarıya indiğinde alan dörtte bire düşer. Yani harita küçülmesi, oyuncunun gözünde göründüğünden daha sert bir alan kaybı yaratabilir.

Yaşayan oyuncu sayısını $N(t)$ ile gösterirsek ortalama yoğunluk $ρ(t)=N(t)/A(t)$ olur. Oyuncu sayısı azalmasına rağmen alan daha hızlı küçülüyorsa yoğunluk artabilir. Bunun karşılaşma ihtimalini yükseltmesi beklenir; fakat oyuncular eşit dağılmadığından bu, kesin bir çatışma formülü değildir. Binalar, görüş çizgileri ve yüksek araziler sonucu değiştirir.

Çemberin Davranışsal Etkisi

Daralan bölge, hareketsiz kalmanın maliyetini yükseltir. Normalde güvenli görünen bir bina, birkaç dakika sonra tehlikeli bir tuzağa dönüşebilir. Böylece oyun, oyuncuyu zorunlu hareket ile taktiksel bekleme arasında seçim yapmaya iter.

Erken hareket eden oyuncu uygun siper bulabilir; fakat merkezde daha fazla yönden tehdit alabilir. Kenarda kalan oyuncu arkasını daha kolay kontrol edebilir, ancak sonraki bölgeye uzun yol katetmek zorunda kalabilir. Dolayısıyla “merkeze koşmak” her durumda en iyi strateji değildir.

Bu yapı karar teorisiyle okunabilir: Oyuncu beklenen kazancı, hasar riskini ve zaman maliyetini birlikte değerlendirir. Çember bu maliyetleri sürekli değiştirerek aynı taktiğin bütün maç boyunca işe yaramasını engeller.

Küçük Bir Python Davranış Modeli

Aşağıdaki örnek, botun olası hedef noktalarını yolculuk süresi, bölge dışında kalma ve görünürlük riski üzerinden puanlar. Düşük puanlı hedef tercih edilir:

import math


def radius_at(t, start=1000, end=250, delay=60, duration=120):
    progress = min(1.0, max(0.0, (t - delay) / duration))
    return start + (end - start) * progress


def choose_target(position, candidates, center, radius, speed=6):
    def cost(point):
        travel_time = math.dist(position, point) / speed
        outside = max(0.0, math.dist(point, center) - radius)
        exposure = candidates[point]
        return travel_time + 0.4 * outside + 12 * exposure

    return min(candidates, key=cost)


candidates = {(100, 100): 0.8, (300, 50): 0.2, (600, 0): 0.1}
future_radius = radius_at(120)
target = choose_target((500, 100), candidates, (0, 0), future_radius)
print(target)

radius_at, bekleme süresinden sonra yarıçapı doğrusal küçültür. choose_target ise adayların görünürlük değerlerini kullanır; bu değerler burada elle verilmiştir. Katsayılar farklı maliyetleri ortak bir tercih puanına dönüştüren tasarım ağırlıklarıdır, fiziksel hasar hesabı değildir.

Bu model engelleri ve hareket sırasında değişen çemberi hesaba katmaz. Gerçek bir oyunda yol bulma, takım bilgisi ve bölge hasarı da değerlendirmeye eklenmelidir.

İyi Baskı, Kötü Sürprizden Nasıl Ayrılır?

Başarılı bir çember sistemi oyuncuyu sıkıştırırken karar verecek zaman bırakır. Belirsizlik heyecan yaratır; okunamayan veya ulaşılması aşırı zor bölgeler ise sonucu beceriden çok şansa bağlayabilir.

Geliştiriciler daralma hızını, uyarı süresini ve dışarıda alınan hasarı birlikte ayarlamalıdır. Çok yavaş çember temposuzluk, çok hızlı çember ise sürekli koşu üretir. Telemetride bölge kaynaklı ölümler, hareketin başlama zamanı ve çatışmaların konumu izlenebilir; ancak bu ölçümler oyuncu deneyimiyle birlikte yorumlanmalıdır.

Sonuçta daralan harita yalnızca oyuncuları yaklaştırmaz: Kaynakların değerini, risk algısını ve zamanın önemini değiştirir. Battle Royale’ın güçlü numarası budur; basit bir geometrik kural, her maçta farklı bir stratejik hikâye üretir.

``

Önce mantık: Başlık dosyası ne sağlar?

#include, ilgili başlık dosyasını programa dahil eder. Başlıklar, fonksiyon bildirimlerini, türleri ve gerekli makroları sunar; fonksiyonların gerçek uygulamaları ise kütüphanelerdedir. Derleyici çağrının türlerini denetler, bağlayıcı gerekli uygulamaları birleştirir. Kısacası başlık dosyası menüdür; yemeği hazırlayan mutfak, kütüphanenin uygulamasıdır. Bu ayrım, derleme hatasıyla bağlama hatasını birbirinden ayırmayı kolaylaştırır.

Matematik: Formülü yeniden icat etmeyin

<math.h>, kayan noktalı hesaplamalar için temel araç kutusudur. sqrt(x) karekök, pow(x, y) üs, fabs(x) mutlak değer hesaplar. Tamsayılar için kullanılan abs ise <stdlib.h> içindedir. floor, ceil ve round farklı yuvarlama kurallarına sahiptir; özellikle negatif sayılarda birbirlerinin yerine kullanılmamalıdır.

İki noktanın uzaklığı şu bağıntıyla bulunur:

Bu hesap için hypot(dx, dy), ara işlemlerde taşma ve aşırı küçülme riskini azaltabilir. Trigonometrik fonksiyonlar radyan bekler. Ayrıca kayan nokta sonuçları yaklaşık olabilir; matematikteki eşitlik, bilgisayarda her zaman birebir eşitlik değildir. Negatif bir değerin karekökü gibi tanım dışı girdilerin hata davranışı da kontrol edilmelidir.

Metin işleme: Sonlandırıcı karakteri unutmayın

C dizeleri, \0 karakteriyle biten karakter dizileridir. strlen, bu sonlandırıcıdan önceki baytların sayısını verir; UTF-8 metindeki görünen harf sayısını garanti etmez. strcmp eşitlik durumunda sıfır döndürür, diğer durumlarda işaretine bakılır; yalnızca -1 veya 1 döneceğini varsaymayın.

memcpy, belirtilen sayıda baytı kopyalar ve bölgeler örtüşmemelidir. Örtüşme ihtimali varsa memmove kullanılır. strncpy ise her durumda sonlandırıcı eklemez; adı güvenlik garantisi değildir. Dize fonksiyonları sonlandırıcıya, bellek fonksiyonları verilen uzunluğa güvenir.

<ctype.h> fonksiyonlarına sıradan bir char verirken (unsigned char) dönüşümü yapmak önemlidir; negatif karakter değerleri tanımsız davranışa neden olabilir.

Bellek yönetimi: Alanın sahibi sizsiniz

Dinamik bellek, boyutu çalışma sırasında belirlenen verileri saklamaya yarar. Ayırdığınız alanın kapasitesi ile içine koyduğunuz verinin uzunluğu farklı kavramlardır. Dize için gereken kapasite genellikle $uzunluk + 1$ bayttır; fazladan bayt sonlandırıcı içindir. Ayırma işleminin başarısız olabileceğini de unutmamak gerekir.

Birlikte çalışan küçük bir örnek

Aşağıdaki program bir metni dinamik belleğe kopyalar, kapasitesini artırır ve matematik fonksiyonlarıyla sonuç üretir. Böylece üç araç kutusunu aynı yerde görürüz.

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void) {
    const char *kaynak = "Merhaba C";
    size_t kapasite = strlen(kaynak) + 1;
    char *metin = malloc(kapasite);
    if (metin == NULL) {
        return EXIT_FAILURE;
    }

    memcpy(metin, kaynak, kapasite);
    char *yeni = realloc(metin, kapasite + 16);
    if (yeni == NULL) {
        free(metin);
        return EXIT_FAILURE;
    }
    metin = yeni;
    strcat(metin, "!");

    printf("%s | Uzunluk: %zu | Kok: %.2f | Us: %.2f\n",
           metin, strlen(metin), sqrt(9.0), pow(2.0, 3.0));
    free(metin);
    return EXIT_SUCCESS;
}

memcpy, sonlandırıcı dahil bütün diziyi kopyalar. Eklenen kapasite, ünlem ve sonlandırıcı için yeterlidir. realloc sonucu geçici işaretçide tutulur: Sıfırdan büyük boyutla yapılan çağrı başarısız olursa eski alan geçerliliğini korur. Sonucu doğrudan metin üzerine yazmak, eski adresi kaybettirebilir.

Birçok Unix benzeri ortamda matematik kütüphanesini ayrıca bağlamak gerekir:

cc -std=c11 -Wall -Wextra main.c -o uygulama -lm

Son kontrol listesi basittir: Kapasiteleri doğrulayın, dönüş değerlerini inceleyin ve ayırdığınız belleği bırakın. Genel boyut hesaplarında n * sizeof(eleman) çarpımının taşmasını önceden denetleyin. Serbest bırakılmış belleğe erişmeyin. Hazır fonksiyonlar işi hızlandırır; güvenli kullanım ise hâlâ programcının sorumluluğudur.

``

Önce mantık: Nesne mi, kaynak mı kopyalanıyor?

Kopyalama kurucusu yeni bir nesneyi mevcut nesneden oluşturur: Buffer b = a;. Kopyalama atama operatörü ise zaten yaşayan bir nesnenin değerini değiştirir: b = a;. İkinci durumda hedefin önceki kaynakları da hesaba katılmalıdır.

Derleyicinin ürettiği işlemler, taban sınıfları ve üyeleri kendi kopyalama davranışlarıyla kopyalar. Bu nedenle otomatik kopyalama, her zaman “sığ kopyalama” demek değildir: std::vector kendi elemanlarını kopyalar. Fakat ham işaretçi üyesinde yalnızca adres kopyalanır:

İki farklı nesne artık aynı kaynağa bakmaktadır. Bunun doğru olup olmadığı, sınıfın sahiplik sözleşmesine bağlıdır.

Tehlikenin klasik hali: İki sahip, tek bellek

Aşağıdaki sınıf belleği kendisi ayırıyor ve yok edilirken serbest bırakıyor. Dolayısıyla işaretçinin sahibi olduğunu varsayıyor:

struct BadBuffer {
    char* data = new char[16];

    ~BadBuffer() {
        delete[] data;
    }
};

void example() {
    BadBuffer a;
    BadBuffer b = a; // Yalnızca adres kopyalanır.

    BadBuffer c;
    c = a;          // c'nin eski belleği kaybolur.
}

Kopyalama kurucusu burada iki nesneye aynı adresi verir. Nesneler yok edildiğinde aynı bellek tekrar serbest bırakılmaya çalışılır: tanımsız davranış ortaya çıkar. Program çökebilir, sessizce bozulabilir veya şimdilik çalışıyor gibi görünebilir.

Atama daha da sinsidir: c kendi eski adresini kaybettiği için bellek sızıntısı oluşturur; ardından ortak adres nedeniyle aynı serbest bırakma sorununa katılır. Derleyici fotokopi çekmiştir, ama herkes belgenin tek sahibi olduğunu sanmaktadır!

Benzer riskler dosya tanıtıcıları ve işletim sistemi tutamaçlarında da vardır. Ayrıca başka bir üyeye işaret eden iç işaretçiler kopyalandığında, yeni nesne yanlışlıkla eski nesnenin içine bakabilir. Sorun yalnızca delete değildir; sınıfın değişmezlerinin bozulmasıdır.

Elle çözüm: Derin kopyalama ve güvenli atama

Bağımsız sahiplik istiyorsak, yeni bellek ayırıp içeriği kopyalamalıyız. Atamada ise mevcut kaynağı koruyarak ilerlemek önemlidir. Aşağıdaki copy-and-swap yaklaşımı, önce kopyayı hazırlar; başarılı olursa kaynakları değiş tokuş eder:

#include <algorithm>
#include <cstddef>
#include <utility>

class Buffer {
    std::size_t size_;
    char* data_;

public:
    explicit Buffer(std::size_t size)
        : size_(size), data_(new char[size]{}) {}

    Buffer(const Buffer& other)
        : Buffer(other.size_) {
        std::copy_n(other.data_, size_, data_);
    }

    ~Buffer() {
        delete[] data_;
    }

    void swap(Buffer& other) noexcept {
        std::swap(size_, other.size_);
        std::swap(data_, other.data_);
    }

    Buffer& operator=(Buffer other) {
        swap(other);
        return *this;
    }
};

Değerle alınan other, bağımsız kopyadır. Bellek ayırma başarısız olursa hedef nesne değişmez. Takastan sonra hedefin eski belleğini other temizler. Bu yaklaşım kendine atamayı da güvenle karşılar; ancak gereksiz bir kopyalama yapabilir.

$n$ baytlık veri için derin kopyalamanın zaman ve ek bellek maliyeti yaklaşık $O(n)$ düzeyindedir. Doğruluk bedava değildir, fakat tanımsız davranış çok daha pahalıdır.

Daha iyi seçenek: Rule of Zero

Rule of Three, yıkıcı, kopyalama kurucusu veya kopyalama atamasını özelleştiriyorsanız diğerlerini de değerlendirin der. Modern C++’ta taşıma işlemleriyle birlikte Rule of Five gündeme gelir. Yukarıdaki sınıf güvenli kopyalanır, fakat özel taşıma işlemleri sağlamaz; taşıma beklenen bazı durumlarda kopyalama yapılabilir.

Çoğu uygulamada en temiz çözüm, kaynak yönetimini hazır türlere devretmektir:

#include <vector>

struct Buffer {
    std::vector<char> data;
};

Bu tasarımda Rule of Zero uygulanır: özel yıkıcı veya kopyalama işlemleri yazmanız gerekmez. std::unique_ptr ise tek sahipliği ifade eder; onu içeren sınıfın otomatik kopyalama işlemleri genellikle silinir.

Son kontrol sorusu şudur: Bu nesneyi kopyaladığımda kaynak paylaşılmalı mı, çoğaltılmalı mı, yoksa kopyalama yasaklanmalı mı? Cevap açık değilse, otomatik üretilen işlemlere güvenmeden önce sahiplik modelini netleştirin.

Evde herkes aynı asistana “En sevdiğim şarkıyı aç” dediğinde farklı listelerin çalması küçük bir sihir gibi görünür. Oysa asistanın içinde aile albümü değil, seslerden çıkarılmış matematiksel temsiller vardır. Peki babanın sabah mahmurluğunu, annenin fısıltısını ve kardeşinizin taklidini nasıl değerlendirir? Gelin bu dijital kulakların çalışma mantığını keşfedelim.

``

Ne söylendiği ile kimin söylediği farklı sorulardır

Otomatik konuşma tanıma, sesi metne dönüştürür. Konuşmacı tanıma ise sesin sahibini araştırır. Burada iki ayrı görev bulunur: kimlik belirleme, kayıtlı kişiler arasından konuşmacıyı seçer; kimlik doğrulama, öne sürülen bir kimliğin doğru olup olmadığını sınar.

Dolayısıyla kişisel müzik listesini seçmek ile “Ben Ayşe’yim, hesabıma erişmek istiyorum” iddiasını değerlendirmek aynı problem değildir. Üstelik sistem her duyduğu sesi aileden birine zorla eşlememelidir; misafirler de kapıyı çalabilir!

Ses nasıl matematiksel bir profile dönüşür?

İlk adım, konuşma etkinliği algılama ile sessizlikleri ayıklamaktır. Ardından ses uygun örnekleme hızına getirilir; modelin beklediği biçimde log-Mel spektrogram gibi özellikler hazırlanır. Bunlar, frekans içeriğinin zaman boyunca nasıl değiştiğini gösterir.

ECAPA-TDNN gibi eğitilmiş modeller bu özelliklerden konuşmacı gömmesi, yani sabit uzunluklu bir vektör üretir. Eğitim sırasında amaç, aynı kişinin farklı kayıtlarını yakın; farklı kişilerin kayıtlarını uzak konumlandırmaktır. Model yalnızca sesin kalınlığına bakmaz; konuşmacıya özgü çeşitli akustik örüntüleri birlikte değerlendirir.

Kayıt aşamasında farklı cümleler, günler ve makul mikrofon uzaklıkları kullanmak faydalıdır. Normalize edilmiş örneklerin ortalaması, yeniden normalize edilerek kişinin referans profiline dönüştürülebilir. Böylece tek bir hapşırık profilin başrol oyuncusu olmaz.

İki temsil arasındaki yakınlık için kosinüs benzerliği kullanılabilir:

Bu ölçü, vektörlerin büyüklüğünden çok yönlerinin benzerliğini değerlendirir. Ancak yüksek benzerlik, tek başına kesin kimlik kanıtı değildir.

Python ile küçük bir karar mekanizması

Aşağıdaki kod ham sesi işlemez; önceden eğitilmiş bir modelin ürettiği, aynı boyuttaki gömme vektörlerini kullanır. profiller, kişi adlarını referans vektörlerine bağlayan bir sözlüktür. Örnek, en az iki kayıtlı kişi varsayar.

import numpy as np


def birim(v):
    v = np.asarray(v, dtype=float)
    norm = np.linalg.norm(v)
    if norm < 1e-8:
        raise ValueError("Geçersiz temsil")
    return v / norm


def profil_olustur(ornekler):
    ortalama = np.mean([birim(v) for v in ornekler], axis=0)
    return birim(ortalama)


def tanila(vektor, profiller, esik=0.75, marj=0.08):
    sorgu = birim(vektor)
    puanlar = sorted(
        ((ad, float(sorgu @ birim(p)))
         for ad, p in profiller.items()),
        key=lambda sonuc: sonuc[1], reverse=True
    )
    (ad, en_iyi), (_, ikinci) = puanlar[:2]
    if en_iyi < esik or en_iyi - ikinci < marj:
        return "Bilinmeyen"
    return ad

profil_olustur, birden fazla kaydı tek referansa indirger. tanila ise en güçlü eşleşmeyi bulur. İkinci adayla fark küçükse karar vermekten kaçınır. Buradaki sayılar yalnızca gösterim içindir; her model için geçerli güvenlik sınırları değildir.

Eşik seçimi: Fazla şüpheci mi, fazla misafirperver mi?

Doğrulamada karar genellikle $s \geq \tau$ koşuluna dayanır. Eşik yükseldikçe yabancıları kabul etmek zorlaşır; fakat gerçek kullanıcıları reddetmek de kolaylaşabilir. Bu dengeyi ölçmek için yanlış kabul oranı ve yanlış ret oranı birlikte izlenir.

Eşikler, aile üyeleriyle birlikte kayıtlı olmayan kişilerden alınmış izinli test verileriyle ayarlanmalıdır. Kayıt ve test oturumlarını ayırmak önemlidir: aynı kaydı iki tarafta kullanmak, sınavdan önce cevap anahtarını dağıtmaya benzer. Gürültü, hastalık ve kısa komutlar ayrıca sınanmalıdır.

Gerçek evlerde güvenlik ve mahremiyet

Televizyon sesi, üst üste konuşmalar ve uzaktaki mikrofon performansı düşürebilir. Sistem emin olmadığında yeniden konuşma istemeli veya kişiselleştirmeden devam etmelidir. Ses kayıtları ve gömmeler hassas biyometrik verilerdir; açık onay, şifreleme, silme seçeneği ve mümkünse cihaz üzerinde işleme gerekir.

Kayıt oynatma ve sentetik ses saldırıları da unutulmamalıdır. Canlılık kontrolleri riski azaltabilir ama kusursuz değildir. Kapı açma veya ödeme gibi işlemlerde ses, tek doğrulama faktörü olmamalıdır. Akıllı asistanın en değerli becerisi bazen doğru kişiyi tanımak değil, “Emin değilim” diyebilmektir.

``

Önce nesneyi bul, sonra kimliği araştır

Görüntü, bilgisayar açısından piksel değerlerinden oluşan bir matristir. Derin öğrenme modelleri bu değerlerden kenar, doku, biçim ve daha karmaşık görsel örüntüler çıkarır. Ancak bir insanı bulmak, yüzünü bulmak ve kim olduğunu belirlemek farklı problemlerdir. Kamera önce sahneyi anlamalı, sonra uygun yüz görüntülerini incelemelidir. Böylece koltuk desenini aile üyesi olarak kaydetme gibi komik ama maliyetli hatalar azalır.

Kameradan karşılaştırmaya uzanan yol

İlk adımda YOLO benzeri bir nesne algılayıcı insanları işaretleyebilir. Ardından ayrı bir yüz tespit modeli, insan bölgelerinde yüz arar. Göz ve burun gibi referans noktalarıyla yapılan hizalama, başın eğikliğinin karşılaştırmayı gereksiz yere bozmasını azaltır.

Kırpılan yüz, modelin beklediği boyuta ve renk düzenine dönüştürülür. Bulanık, çok küçük veya aşırı karanlık görüntüler elenebilir. Bu kalite kontrolü önemlidir: Algoritmaya belirsiz bir görüntü verip kesin cevap beklemek, buğulu gözlükle kimlik kontrolü yapmaya benzer. Her karede işlem yapmak yerine takip algoritmalarıyla aynı kişiyi izlemek de hesaplama yükünü azaltabilir.

Yüzün sayısal özeti: embedding

Yüz tanıma modeli, görüntüyü çoğunlukla yüzlerce bileşenden oluşan bir özellik vektörüne, yani embedding’e dönüştürür. Eğitim sırasında aynı kişinin görüntülerinin birbirine yakın, farklı kişilerin görüntülerinin daha uzak temsil edilmesi hedeflenir. Bu vektör doğrudan isim içermez; isim, izinle oluşturulmuş kayıtlı örneklerle eşleştirme sonucunda bulunur.

İki vektör arasındaki kosinüs benzerliği şöyle hesaplanabilir:

Birim uzunluğa normalize edilmiş vektörlerde hesap, yalnızca iç çarpıma dönüşür. Yüksek benzerlik aynı kişiye işaret edebilir; fakat skor, kendiliğinden bir doğruluk olasılığı değildir. Örneğin $0.80$, otomatik olarak “yüzde 80 kesinlik” anlamına gelmez.

Tanıdık mı, yoksa sadece benziyor mu?

Ev ortamında sistem açık küme tanıma yapmalıdır: Görülen herkesin kayıtlı kişilerden biri olduğunu varsayamaz. En yüksek benzerlik bile belirlenen eşikten düşükse sonuç “bilinmiyor” olmalıdır.

Eşik düşürülürse tanıdıkları kaçırma azalabilir, ancak yabancıları yanlış kabul etme artabilir. Eşik yükseltilirse bunun tersi yaşanabilir. Doğru değer; kamera açısı, ışık, model ve kayıt kalitesiyle değişir. Bu nedenle yanlış kabul ve yanlış ret oranları, farklı koşullarda toplanmış doğrulama örnekleriyle birlikte değerlendirilmelidir.

Python ile küçük bir eşleştirme katmanı

Aşağıdaki kod yüzü görüntüden çıkarmaz; aynı modelden alınmış embedding’leri karşılaştırır. kayitlar, kişi adlarını referans vektörlerine bağlayan bir sözlüktür.

import numpy as np

def birim(vektor):
    v = np.asarray(vektor, dtype=float)
    uzunluk = np.linalg.norm(v)
    if uzunluk < 1e-12:
        raise ValueError("Geçersiz embedding")
    return v / uzunluk

def eslestir(yuz, kayitlar, esik=0.65):
    if not kayitlar:
        return "bilinmiyor", None
    sorgu = birim(yuz)
    skorlar = {
        kisi: float(sorgu @ birim(referans))
        for kisi, referans in kayitlar.items()
    }
    aday = max(skorlar, key=skorlar.get)
    skor = skorlar[aday]
    sonuc = aday if skor >= esik else "bilinmiyor"
    return sonuc, skor

Buradaki 0.65 yalnızca örnektir; başka modellerde güvenilir olmayabilir. Gerçek uygulamada kişi başına farklı ışıklarda birkaç referans tutulabilir. Yakın skorlu iki aday varsa karar ertelenebilir. Ayrıca birkaç ardışık karede tutarlı eşleşme aramak, tek karelik hataları azaltır; ancak hataları tamamen ortadan kaldırmaz.

Güvenlik, mahremiyet ve son karar

Yüz embedding’leri biyometrik veri niteliği taşıyabilir; zararsız sayı dizileri gibi görülmemelidir. Ev sakinlerinin bilgilendirilmesi, uygun izinlerin alınması, yerel işleme, şifreleme, erişim kısıtlamaları ve kısa saklama süreleri önemlidir. Gereksiz görüntüler tutulmamalı, misafirler için mahremiyet seçenekleri sunulmalıdır.

Fotoğraf veya ekranla kandırılmaya karşı canlılık kontrolleri eklenebilir; bunlar da kusursuz değildir. “Bilinmiyor” etiketi yalnızca güvenilir eşleşme bulunamadığını söyler, kötü niyet göstermez. En iyi dijital kapıcı, herkesi tanıdığını iddia eden değil; emin olmadığında bunu söyleyen ve önemli kararları insana bırakan sistemdir.

Bir yatırımın geleceğini tek hücrelik Excel tahminine bağlamak, hava durumuna bakmadan pikniğe çıkmaya benzer: Bazen güneş açar, bazen sandviçler yüzer. Bilgisayar destekli finansal modelleme, gelirleri, maliyetleri ve belirsizlikleri açık varsayımlara dönüştürür. Böylece yalnızca “Ne kadar kazanırız?” sorusunu değil, “Hangi koşullarda zarar ederiz?” sorusunu da araştırabiliriz. Üstelik farklı kararları aynı deney düzeneğinde karşılaştırabiliriz.

``

Önce teori: Paranın zaman makinesi

Bugünkü 100 lira ile beş yıl sonraki 100 lira aynı ekonomik değere sahip değildir. Enflasyon, alternatif yatırım getirileri ve risk nedeniyle gelecekteki nakit akışlarını bugüne indirgeriz. Net bugünkü değer, yani NPV, bu yaklaşımın temel araçlarından biridir:

Burada $I_0$ başlangıç yatırımı, $CF_t$ ilgili yılın nakit akışı, $r$ iskonto oranı ve $T$ modelin süresidir. Pozitif NPV, kullanılan iskonto oranı ve varsayımlar altında yatırımın değer yaratabileceğini gösterir; kesin kazanç sözü vermez.

Örneğimizde başlangıç yatırımı bir milyon lira, başlangıç yıllık gelir seviyesi 800 bin liradır. Değişken maliyetleri gelir üzerinden, sabit giderleri ayrı hesaplayacağız. Vergileri, işletme sermayesini, ek yatırımları ve terminal değeri dışarıda bırakıyoruz. Dolayısıyla bu, gerçek yatırım kararına hazır bir değerleme değil, öğretici bir prototiptir.

Senaryodan olasılık dağılımına

Önce üç anlaşılır senaryo tanımlayalım. Bu tablo, değişkenlerin etkisini sezmek içindir; simülasyonun yüzdelik sonuçlarını temsil etmez.

Monte Carlo yöntemi, bu üç fotoğraf yerine binlerce olası kombinasyon üretir. Her kombinasyonda nakit akışları ve NPV yeniden hesaplanır. Sonuç, tek bir tahmin değil, varsayımlara bağlı bir sonuç dağılımıdır. Bilgisayarın yaptığı sihir değil; sistematik biçimde çok sayıda “ya şöyle olursa?” sorusu sormaktır.

Python ile finansal deney düzeneği

Önce pip install numpy komutuyla NumPy’ı kurun. Aşağıdaki kod 10.000 senaryo oluşturur. Büyüme ve iskonto oranlarını sınırlandırılmış normal dağılımlardan, maliyet oranını ise minimum, en olası ve maksimum değerleri tanımlanabilen üçgensel dağılımdan örnekler:

import numpy as np

rng = np.random.default_rng(42)
n = 10_000
years = np.arange(1, 6)

growth = np.clip(
    rng.normal(0.08, 0.04, (n, 1)), -0.08, 0.22
)
cost_ratio = rng.triangular(0.45, 0.55, 0.65, (n, 1))
discount = np.clip(
    rng.normal(0.12, 0.02, (n, 1)), 0.05, 0.20
)

revenue = 800_000 * (1 + growth) ** years
fixed_cost = 170_000 * 1.04 ** years
cash_flow = revenue * (1 - cost_ratio) - fixed_cost

npv = (
    cash_flow / (1 + discount) ** years
).sum(axis=1) - 1_000_000

p5, median, p95 = np.quantile(npv, [0.05, 0.50, 0.95])
print(f"NPV yüzdelikleri: {p5:,.0f}, {median:,.0f}, {p95:,.0f} TL")
print(f"Negatif NPV oranı: {np.mean(npv < 0):.1%}")

Rastgele sayı üretecindeki 42, deneyin tekrarlanabilmesini sağlar. (n, 1) biçimindeki diziler, beş yıllık zaman dizisiyle yayınlama sayesinde birleşir; Python döngüsü yazmadan bütün senaryolar hesaplanır. Her senaryoda seçilen büyüme, maliyet ve iskonto oranı beş yıl boyunca sabittir. Yani burada yıllık şokları değil, model parametrelerindeki belirsizliği örnekliyoruz. Ayrıca 800 bin lira başlangıç seviyesidir; ilk yıl geliri büyüme uygulanarak bulunur.

Sonuçları doğru okumak

Medyan, sonuçların ortasındaki değerdir. Beşinci yüzdelik, simülasyon sonuçlarının yaklaşık %5’inin altında kaldığı eşiği gösterir. Beşinci ve doksan beşinci yüzdelikler arasındaki bölge, model sonuçlarının merkezdeki yaklaşık %90’ını kapsar; medyan için bir güven aralığı değildir.

Negatif NPV oranı da şirketin iflas olasılığı değildir. Yalnızca seçilen dağılımlar altında yatırımın iskonto edilmiş değerinin başlangıç maliyetini karşılamama sıklığıdır. Modeli bir kristal küre değil, varsayımlarınızı sorgulayan bir laboratuvar olarak düşünün.

Modeli gerçek hayata yaklaştırmak

• Veriyle kalibre edin: Dağılımları geçmiş satışlar, maliyetler ve piyasa verileriyle gerekçelendirin. Kırpma işlemi sınır noktalarında olasılık yığılması oluşturur.
• Bağımlılıkları modelleyin: Örnekte değişkenler bağımsızdır. Gerçekte yüksek büyüme, yüksek maliyet veya farklı risk primiyle birlikte gelebilir.
• Tutarlılığı koruyun: Nominal nakit akışlarını nominal iskonto oranıyla değerlendirin. Sabit giderlerin yıllık %4 artması açık bir varsayımdır.
• Duyarlılığı ölçün: Bir varsayımı değiştirip diğerlerini sabit tutarak NPV’nin hangi girdiye daha hassas olduğunu inceleyin.
• Nakit ile kârı ayırın: Tahsilat gecikmeleri, vergiler ve stok finansmanı eklenmeden muhasebe kârını nakit akışı sanmayın.

Son olarak senaryo sayısını artırıp yüzdeliklerin kararlı olup olmadığını kontrol edin. Daha fazla simülasyon örnekleme gürültüsünü azaltır; yanlış varsayımları düzeltmez. Finansal modellemenin asıl gücü geleceği bilmek değil, belirsizliği görünür ve tartışılabilir hâle getirmektir.

``

Temel Mantık: Olay, Koşul ve Eylem

IFTTT adı, “If This Then That” ifadesinden gelir: “Bu olursa, şunu yap.” Platformdaki otomasyon tariflerine Applet denir. Basit bir Applet, bir servisin tetikleyicisini başka bir servisin eylemine bağlar.

Burada üç kavramı ayırmak önemlidir. Olay, sistemde gerçekleşen değişikliktir. Koşul, olayın işlenmeye değer olup olmadığını belirler. Eylem ise başka bir sistemde oluşturulan sonuçtur. Örneğin yeni bir kayıt olaydır; kaydın acil olması koşuldur; bildirim göndermek eylemdir.

Bu ilişkiyi şöyle gösterebiliriz:

Burada $E$, ilgili olayın gerçekleşmesini; $C$, ek koşulun sağlanmasını; $A$ ise eylemin çalıştırılmasını temsil eder. Yalnızca tetikleyici kullanan basit tariflerde ek koşulu sürekli doğru kabul edebilirsiniz.

Önemli ayrıntı: İki bağımsız tetikleyiciyi otomatik olarak “VE” mantığıyla birleştiremezsiniz. Ek filtreler, çoklu eylemler ve kullanılabilir servisler hesap planına veya entegrasyona göre değişebilir. Karmaşık kararlar için araya kendi küçük uygulamanızı koyabilirsiniz.

Zincirler Neden Asenkron Çalışır?

Servisler aynı programın fonksiyonları değildir. Aralarında ağ bağlantıları, kimlik doğrulama ve bekleme süreleri bulunur. Bazı tetikleyiciler değişiklikleri belirli aralıklarla kontrol eder; bazıları ise olay geldiğinde doğrudan haber verir. Bu ikinci yaklaşımın yaygın araçlarından biri webhook mekanizmasıdır.

Webhook, kabaca “Bir şey olduğunda şu adrese HTTP isteği gönder” anlaşmasıdır. Kapıyı sürekli kontrol etmek yerine zil takmak gibi düşünün. Yine de zilin çalması, içerideki herkesin işini tamamladığı anlamına gelmez!

Bir zincirin yaklaşık gecikmesi şöyle modellenebilir:

Bu yüzden bildirim otomasyonları için uygun bir zincir, milisaniyelik tepki gerektiren kontrol sistemleri için uygun olmayabilir.

Uygulama: Acil GitHub Kaydını Telefona Taşıyalım

Örnek mimarimiz şöyle olsun: GitHub webhook → Python uygulaması → IFTTT Webhooks → telefon bildirimi. GitHub olayını alan uygulama, issue verisini inceler; yalnızca urgent etiketli kayıtları IFTTT’ye iletir.

IFTTT tarafında önce Webhooks servisindeki Receive a web request tetikleyicisini seçin. Olay adını urgent_issue yapın. Ardından Notifications servisindeki bildirim eylemini seçerek mesajda Value1 ve Value2 alanlarını kullanın. Webhooks anahtarınızı ortam değişkenine kaydedin; kaynak koduna veya herkese açık depoya koymayın.

Aşağıdaki fonksiyon, sunucunuzun doğruladığı webhook içeriğindeki issue nesnesini işler. requests paketinin kurulu olması gerekir:

import os
import requests

processed = set()

def route_issue(issue):
    issue_id = str(issue["id"])
    labels = {item["name"] for item in issue.get("labels", [])}

    if "urgent" not in labels or issue_id in processed:
        return "atlandı"

    key = os.environ["IFTTT_WEBHOOK_KEY"]
    url = f"https://maker.ifttt.com/trigger/urgent_issue/with/key/{key}"
    response = requests.post(
        url,
        json={"value1": issue["title"], "value2": issue["html_url"]},
        timeout=5,
    )
    response.raise_for_status()
    processed.add(issue_id)
    return "iletildi"

Fonksiyon etiketi denetler, başlık ve bağlantıyı gönderir, başarılı HTTP yanıtından sonra kaydı işaretler. Bu yanıt, telefon bildiriminin kesin teslim edildiğini kanıtlamaz. GitHub webhook imzasının doğrulanması ve ilgili olay türlerinin seçilmesi, bu fonksiyonu çağıran sunucunun sorumluluğudur.

Sağlam Zincirin Görünmeyen Kuralları

Örnekteki bellek kümesi yalnızca prototip içindir: uygulama yeniden başladığında temizlenir ve eşzamanlı çağrılarda yarış koşullarını engellemez. Üretimde kalıcı kayıtlar ve atomik kontroller kullanın. Aynı girdinin tekrar işlenmesinin istenmeyen ek sonuç üretmemesine idempotent davranış denir.

Son olarak her adımı kaydedin, ancak anahtarları ve hassas verileri loglardan çıkarın. Başarısızlıkları görünür kılın ve yeniden denemeleri sınırlayın. İyi otomasyon, her şeyi körlemesine yapan değil; ne zaman duracağını da bilen dijital yardımcıdır.

``

Önce mantık: Fiyat hangi ilişkiden doğar?

Konut fiyat tahmini, hedef değişkeni sayısal olan bir regresyon problemidir. Her konut bir gözlem; alan, bina yaşı ve ulaşım mesafeleri ise özelliklerdir. Temel düşünce şöyledir:

Burada $y$ satış fiyatını, $X$ özellikleri, $f$ öğrenilen ilişkiyi, $e$ ise açıklanamayan etkileri temsil eder. Manzara, pazarlık veya ölçülmeyen yapı kalitesi bu hata payına katkıda bulunabilir.

Doğrusal regresyon, özelliklerin katkılarını ağırlıklı toplamla açıklar. Ağaç tabanlı modeller ise eşikler ve etkileşimler öğrenir: Metro yakınlığı, merkezdeki küçük bir daireyle çeperdeki büyük bir ev için aynı anlamı taşımayabilir. Ancak tahmin ilişkisi nedensellik değildir; metroya yakın evlerin pahalı olması, farkın tamamını metronun yarattığını kanıtlamaz.

Veriyi şehrin haritasıyla buluşturmak

Başlangıçta gerçekleşmiş satış kayıtlarını bina özellikleriyle birleştirin. İlan fiyatları kullanılabilir, fakat bunlar satış fiyatıyla aynı hedef değildir. Koordinatlardan ulaşım duraklarına, okullara ve hizmet noktalarına mesafe üretilebilir. Kuş uçuşu mesafe kolaydır; yol ağı üzerinden seyahat süresi ise günlük yaşamı daha iyi temsil edebilir.

Altyapı puanını ulaşım, internet ve belediye hizmetleri gibi bileşenlerden oluşturabilirsiniz. Bileşenleri ortak ölçeğe getirip ağırlıkları gerekçelendirin. Satış tarihinden sonra açılan metro hattını geçmiş satışa eklemeyin: Modelin geleceği görmesi başarı değil, veri sızıntısıdır. Farklı tarihlerdeki fiyatları da uygun bir endeksle ortak döneme taşımayı değerlendirin.

Hangi modelle başlayalım?

Önce basit bir referans model kurun; ardından karmaşıklığın gerçekten fayda sağlayıp sağlamadığını ölçün.

Ridge için sayısal özellikleri ölçeklemek yararlıdır. Ağaçlar genellikle buna ihtiyaç duymaz. Hiçbir modelin bütün şehirlerde kazanacağına dair garanti yoktur; yarışmanın hakemi doğrulama verisidir, modelin havalı adı değil.

Python ile bölgesel test

Aşağıdaki örnek, belirtilen sütunları içeren bir CSV dosyası bekler. Mahalleleri eğitim ve test arasında ayırarak modelin görmediği bölgelerdeki başarısını sınar. Mahalle kodu tahmin özelliği değil, ayırma grubu olarak kullanılır.

import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import GroupShuffleSplit
from sklearn.metrics import mean_absolute_error

df = pd.read_csv("konutlar.csv").dropna(
    subset=["fiyat_tl", "mahalle_kodu"]
)
num = ["alan_m2", "bina_yasi", "merkeze_km",
       "metroya_m", "okula_m", "altyapi_puani"]
cat = ["yapi_tipi"]
X, y = df[num + cat], df["fiyat_tl"]

categorical = Pipeline([
    ("fill", SimpleImputer(strategy="most_frequent")),
    ("encode", OneHotEncoder(handle_unknown="ignore"))
])
prep = ColumnTransformer([
    ("numeric", SimpleImputer(strategy="median"), num),
    ("categorical", categorical, cat)
])
model = Pipeline([
    ("prep", prep),
    ("forest", RandomForestRegressor(
        n_estimators=300, min_samples_leaf=5,
        random_state=42, n_jobs=-1))
])
split = GroupShuffleSplit(test_size=0.2, random_state=42)
train, test = next(split.split(X, y, df["mahalle_kodu"]))
model.fit(X.iloc[train], y.iloc[train])
pred = model.predict(X.iloc[test])
print("MAE (TL):", mean_absolute_error(y.iloc[test], pred))

Pipeline, eksik değer doldurma ve kategori kodlama işlemlerini yalnızca eğitim verisinden öğrenir. Böylece test verisi hazırlık aşamasına sızmaz. min_samples_leaf, çok küçük örnek gruplarına aşırı uyumu sınırlar.

Sonucu doğru okumak

Ortalama mutlak hata, tahminlerin fiyatlardan ortalama ne kadar saptığını gösterir:

MAE’yi testte, eğitim fiyatlarının medyanını sürekli tahmin eden basit referansla karşılaştırın. Bölge ve fiyat dilimi bazında hataları da inceleyin; genel ortalama, pahalı konutlardaki başarısızlığı gizleyebilir.

Komşu mahalleler hâlâ birbirine benzeyebilir. Daha güçlü değerlendirme için coğrafi tamponlar, birden fazla bölgesel bölme ve gelecekteki satışları sınayan zamansal test kullanın. Hiperparametreleri eğitim içindeki doğrulamayla seçin; nihai testi saklı tutun.

Sonuçta model, otomatik ekspertiz sertifikası değil, karar destek aracıdır. Güvenilir tahmin; temiz veri, gerçekçi test ve açıklanabilir hata analiziyle gelir. Şehrin ritmini öğrenmek, yalnızca daha büyük bir algoritma çalıştırmaktan önemlidir.

``

Önce hedef: Hangi riski ölçüyoruz?

Kredi skorlama genellikle bir ikili sınıflandırma problemidir. Örneğin hedef, kredi açıldıktan sonraki 12 ay içinde müşterinin temerrüde düşüp düşmeyeceğini tahmin etmektir. Temerrüdün tanımı baştan belirlenmelidir; örneğin ödemenin 90 günü aşan gecikmesi kullanılabilir.

Modelin çıktısı çoğunlukla temerrüt olasılığıdır, yani PD. Lojistik regresyonda önce özelliklerin ağırlıklı toplamı hesaplanır, ardından sonuç sigmoid fonksiyonuyla olasılığa dönüştürülür:

Burada $x_i$ müşteri özelliklerini, $w_i$ öğrenilen ağırlıkları, $b$ ise sabit terimi temsil eder. Sigmoid, herhangi bir gerçek sayıyı sıfır ile bir arasına sıkıştırır. Ancak bu çıktının güvenilir bir olasılık olması, modelin ayrıca değerlendirilmesini ve gerektiğinde kalibre edilmesini gerektirir.

Her risk aynı parasal kayıp değildir

Temerrüt olasılığı tek başına bankanın kaybını anlatmaz. Beklenen kayıp için üç bileşen kullanılır:

LGD, temerrüt halinde kaybedilecek pay; EAD, temerrüt anındaki risk tutarıdır. Örneğin PD yüzde 4, LGD yüzde 50 ve EAD 100.000 TL ise beklenen kayıp 2.000 TL olur. Bu, belirli bir müşterinin kesin kaybı değil, benzer durumların ortalamasına ilişkin tahmindir.

Modelin masasına hangi veriler gelir?

Önemli olan yalnızca veri toplamak değil, başvuru anında gerçekten bilinen verileri kullanmaktır. Gelecekteki bir gecikmeyi özelliklere eklemek, sınavdan önce cevap anahtarını görmek gibidir: Buna veri sızıntısı denir.

Düşük gelir otomatik olarak yüksek risk demek değildir. Borç yükü, ödeme düzeni ve ürün özellikleri birlikte değerlendirilir. Ayrıca eğitim verisi yalnızca geçmişte kredi verilen kişilerden oluşuyorsa, reddedilen başvurular hakkında modelin bilgisi sınırlıdır.

Hangi algoritma daha iyi?

Tek bir şampiyon yoktur. Seçim, tahmin başarısı kadar açıklanabilirlik ve bakım maliyetine de bağlıdır.

Python ile küçük bir prototip

Aşağıdaki örnek, varsayımsal bir CSV dosyasındaki sayısal özelliklerle model kurar. temerrut_12ay hedefi 0 veya 1 olmalıdır. Satırlar başvuru tarihine göre sıralanarak daha yeni dönem test için ayrılır.

import pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score, brier_score_loss

df = pd.read_csv("kredi_ornek.csv", parse_dates=["tarih"])
df = df.sort_values("tarih")
features = ["borc_gelir", "gecikme_sayisi", "limit_kullanimi"]
cut = int(len(df) * 0.8)
train, test = df.iloc[:cut], df.iloc[cut:]

model = make_pipeline(
    SimpleImputer(strategy="median"),
    StandardScaler(),
    LogisticRegression(max_iter=1000)
)
model.fit(train[features], train["temerrut_12ay"])
pd_hat = model.predict_proba(test[features])[:, 1]

print("ROC-AUC:", roc_auc_score(test["temerrut_12ay"], pd_hat))
print("Brier:", brier_score_loss(test["temerrut_12ay"], pd_hat))

Pipeline, eksik değer doldurma ve ölçekleme parametrelerini yalnızca eğitim verisinden öğrenir. ROC-AUC sıralama başarısını, Brier skoru olasılık tahminlerinin hatasını ölçer. Gerçek uygulamada eğitim etiketlerinin test dönemi başlamadan olgunlaşması ve aynı müşterinin tekrarlarının sızıntı yaratmaması ayrıca kontrol edilmelidir.

Skor kararın tamamı değildir

Temerrüt nadirse doğruluk yanıltabilir: Herkese “öder” diyen model bile başarılı görünebilir. PR-AUC, kalibrasyon ve farklı müşteri gruplarındaki hata oranları da incelenmelidir. Kredi verme eşiği ise maliyetler, risk politikası ve mevzuatla belirlenir.

Hassas özellikleri çıkarmak tek başına adaleti garanti etmez; diğer değişkenler bunların vekili olabilir. Veri gizliliği, anlaşılır gerekçeler ve itiraz süreçleri önemlidir. Ekonomi değiştikçe model de izlenmelidir. Kısacası iyi skorlama, yalnızca akıllı algoritma değil; temiz veri, dürüst ölçüm ve sorumlu karar sürecidir.