``

Ö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.

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 fizik: Ağ neden bekletir?

Bir komutun istemciden sunucuya ulaşması zaman alır. Gidiş-dönüş süresi RTT, paketin gidip yanıtın geri gelmesini kapsar. Yolların yaklaşık simetrik olduğu varsayılırsa tek yönlü gecikme $d \approx RTT / 2$ olarak tahmin edilebilir; gerçek bağlantılarda bu eşitlik garanti değildir.

Üstelik sorun yalnızca gecikme değildir. Jitter, paketlerin değişken aralıklarla gelmesi; paket kaybı ise bazı güncellemelerin hiç ulaşmamasıdır. Sunucunun tick rate değeri de simülasyonun saniyede kaç kez ilerlediğini belirler. Örneğin 60 Hz sunucuda bir adım yaklaşık 16,7 milisaniyedir.

Çoğu rekabetçi oyunda sunucu otoriterdir: İstemci hareket talep eder, nihai sonucu sunucu belirler. Böylece oyuncunun bilgisayarı hem gösteri sahnesi olur hem de güvenilmeyen bir veri kaynağı olarak değerlendirilir.

Dört teknik, dört farklı görev

Bu yöntemler birbirinin alternatifi değildir. Genellikle aynı oyunda birlikte çalışırlar; çünkü kendi karakterinizi kontrol etmekle uzaktaki oyuncuları izlemek farklı problemler doğurur.

İstemci tahmini ve sunucuyla uzlaştırma

Karakterinizin yürümesi için sunucuyu beklerseniz kontrol ağırlaşır. Bunun yerine istemci girdiyi hemen uygular, aynı girdiyi sunucuya gönderir. Basitleştirilmiş hareket modeli $x_{yeni} = x_{eski} + v a dt$ şeklindedir; burada $a$ yön, $v$ hızdır.

Aşağıdaki JavaScript örneği, tek boyutlu hareketi tahmin eder ve sunucu yanıtıyla yeniden hesaplar:

const speed = 6;
let sequence = 0;
let pending = [];
let predicted = { x: 0 };

function step(state, input) {
  return { x: state.x + speed * input.axis * input.dt };
}

function move(axis, dt) {
  const input = {
    seq: ++sequence,
    axis: Math.max(-1, Math.min(1, axis)),
    dt
  };
  pending.push(input);
  predicted = step(predicted, input);
  send(input);
}

function onSnapshot({ state, lastProcessedSeq }) {
  pending = pending.filter(i => i.seq > lastProcessedSeq);
  predicted = pending.reduce(step, { ...state });
}

Burada send, ağ katmanının sağladığı gönderim fonksiyonudur. Sunucu, işlediği son girdi numarasını bildirir. İstemci onaylanan girdileri siler, sunucu durumundan başlayıp kalanları tekrar uygular. Böylece sunucunun henüz görmediği hareketler kaybolmaz. Örnekteki dt güvenilir sayılmamalıdır; sunucu süreyi, sırayı ve hareket sınırlarını doğrulamalıdır. Gerçek uygulamada sabit simülasyon adımları tercih edilir.

Görsel düzeltme yumuşatılabilir; fakat çarpışma hesabı sırf görüntü güzel olsun diye yanlış konumda bırakılmamalıdır.

Enterpolasyon: Bilerek biraz geriden bakmak

Uzak oyuncuların gelecekteki girdilerini bilemezsiniz. Bunun yerine görüntüyü kısa bir tampon süresi kadar geriden oynatırsınız. İki sunucu örneği arasındaki konum $p(t) = (1-\alpha)p_0 + \alpha p_1$ ile hesaplanır; $\alpha$, iki örnek arasındaki ilerleme oranıdır.

Bu yaklaşım, düzensiz paket gelişlerini akıcı harekete dönüştürür. Tampon küçülürse tepki hızlanır ama takılmalar artabilir. Paket gelmediğinde kullanılan ekstrapolasyon ise son hızdan geleceği tahmin eder; ani dönüşlerde kolayca yanılır. Bu yüzden genellikle kısa süreyle sınırlandırılır.

Geçmişe sarma: Mermiyi hangi zamana göre değerlendirmeli?

Sunucu oyuncu konumlarının kısa bir geçmişini saklar. Ateş komutu geldiğinde, atıcının ekranda gördüğü zamana karşılık gelen konumlarla vuruş testi yapabilir. Basitleştirilmiş hesap $t_{test} = t_{gelis} - d_{yukleme} - D$ şeklindedir; $D$ görüntü tamponudur.

Örneğin yaklaşık 60 milisaniye yükleme gecikmesi ve 80 milisaniye tampon varsa test, komutun gelişinden yaklaşık 140 milisaniye öncesine bakabilir. Gerçek sistemler zaman damgalarını ve saat farklarını ayrıca doğrular.

Bedeli şudur: Hedef, kendi ekranında siper arkasına geçtiği hâlde vurulabilir. Bu nedenle geri sarma penceresi sınırlanır; istemcinin istediği herhangi bir geçmiş zaman kabul edilmez. Dinamik engellerin geçmişi de değerlendirmeyi zorlaştırabilir.

İyi hissettiren oyun ölçülerek yapılır

Tek bir sihirli tampon değeri yoktur. RTT dağılımını, jitter seviyesini, düzeltme miktarını ve reddedilen vuruşları ölçün. Yapay gecikme ve paket kaybıyla test yapın; yalnızca yerel ağda akıcı görünen oyun yanıltıcıdır. Rekabetçi nişancı oyunuyla sıra tabanlı oyunun ihtiyaçları aynı değildir. Amaç gecikmeyi yok etmek değil, tepkisellik, doğruluk ve adalet arasında bilinçli bir denge kurmaktır.

1. Önce fizik: Dinlediğimiz şey ne?

Vücuttaki su ve yağ molekülleri bol miktarda hidrojen içerir. Hidrojen çekirdeklerinin manyetik özellikleri, güçlü bir ana manyetik alan içinde ölçülebilir bir toplam mıknatıslanma oluşturur. Çekirdeklerin karakteristik dönme hareketinin frekansı, Larmor bağıntısıyla açıklanır:

Burada $B_0$ ana manyetik alan, $\gamma$ ise jiromanyetik orandır. Protonlar için $\gamma/(2\pi)$ yaklaşık $42{,}58$ MHz/T olduğundan, 3 teslalık bir cihazda rezonans frekansı yaklaşık 128 MHz olur.

Radyo frekansı darbesi mıknatıslanmayı dengeden uzaklaştırır. Darbe sonrasında değişen mıknatıslanma, alıcı bobinlerde elektriksel sinyal indükler. Dokuların $T_1$ ve $T_2$ gevşeme özellikleri farklıdır; çekim parametreleriyle birlikte görüntü kontrastını belirler. Yani parlaklık, yalnızca “burada ne kadar hidrojen var?” sorusunun cevabı değildir.

2. Konum bilgisi sinyale nasıl eklenir?

Tek bir toplu sinyal, hangi dokunun nerede olduğunu söylemez. Bu, kalabalık bir odadaki bütün konuşmaları tek mikrofonla kaydetmeye benzer. MR’ın çözümü, manyetik alanı konuma göre değiştiren gradyan alanlarıdır.

Kesit seçimi sırasında gradyanla birlikte uygulanan uygun frekans aralığındaki bir RF darbesi, hedeflenen kesiti uyarır. Diğer gradyanlar, sinyale konuma bağlı faz ve frekans farklılıkları ekler.

Her eksendeki k-uzayı koordinatı, ilgili gradyanın zaman içindeki birikimiyle ilişkilidir:

Burada önemli programlama fikri şudur: Cihaz doğrudan piksel adreslerini okumaz. Ölçüm zamanlamasını ve gradyanları kontrol ederek görüntüyü hesaplamaya yetecek veriyi toplar. Böylece donanımın zaman çizelgesi, yazılımın veri koordinatlarına dönüşür.

3. K-uzayı: Görüntünün frekans günlüğü

Toplanan veriler k-uzayı denen uzaysal frekans alanına yerleştirilir. Basitleştirilmiş iki boyutlu model şöyledir:

$m(x,y)$, proton yoğunluğu, gevşeme ve faz etkilerini içeren etkin görüntüdür. Bu sade modelde bobin duyarlılığını sabit kabul ediyoruz.

Ancak tek bir k-uzayı noktası, tek bir görüntü pikseline karşılık gelmez. Her ölçüm, görüntünün tamamına yayılan bir örüntü hakkında bilgi taşır. Asıl sürpriz burada!

4. Bilgisayarın iş akışı

Alıcı sistem sinyali yükseltir, sayısallaştırır ve demodülasyonla karmaşık taban bant verisine dönüştürür. Karmaşık sayılar hem genliği hem fazı saklar; fazı erkenden atmak, konum bilgisini kaybetmek demektir.

Kartezyen örneklemede rekonstrüksiyonun temel adımı ters ayrık Fourier dönüşümüdür. FFT algoritmaları bu hesabı yaklaşık $O(N\log N)$ maliyetle gerçekleştirir. Ardından bobin görüntüleri birleştirilir, gerekli düzeltmeler uygulanır ve sonuç görüntülenir. Kartezyen olmayan örneklemelerdeyse doğrudan standart FFT yerine yeniden örnekleme veya farklı dönüşüm yöntemleri gerekir.

5. Python ile minik bir sanal deney

Aşağıdaki kod, yapay bir nesneden k-uzayı üretir ve ters dönüşümle nesneyi geri getirir. Gerçek MR fiziğini bütünüyle simüle etmez; Fourier ilişkisinin hesaplama tarafını gösterir.

import numpy as np
import matplotlib.pyplot as plt

n = 128
axis = np.linspace(-1, 1, n, endpoint=False)
x, y = np.meshgrid(axis, axis)
phantom = np.exp(-6 * (x**2 + y**2))
phantom += 0.6 * ((x - 0.3)**2 + y**2 < 0.08)

kspace = np.fft.fftshift(
    np.fft.fft2(np.fft.ifftshift(phantom))
)
image = np.fft.fftshift(
    np.fft.ifft2(np.fft.ifftshift(kspace))
)

fig, axes = plt.subplots(1, 2)
axes[0].imshow(np.log1p(np.abs(kspace)), cmap="gray")
axes[1].imshow(np.abs(image), cmap="gray")
plt.show()

fftshift, sıfır frekansı merkeze taşır. Logaritmik gösterim, k-uzayındaki geniş genlik aralığını görünür kılar. Son görüntüde abs, karmaşık sonucun büyüklüğünü gösterir; bazı MR uygulamalarında faz görüntüsü de ayrıca değerlidir.

6. Gerçek dünya neden daha zor?

Hasta hareketi, gürültü ve alan düzensizlikleri ideal modeli bozar. Eksik veri toplamak çekimi hızlandırabilir, fakat bedelsiz değildir:

Modern algoritmalar bu dengeyi yönetir. MR’ın bilgisayar bilimi tam da burada parlar: Görüntü, yalnızca ölçülen bir şey değil; fiziksel model, örnekleme stratejisi ve sayısal hesaplamanın birlikte ürettiği bir sonuçtur.

``

Segmentasyonun arkasındaki fikir

Anlamsal segmentasyon, görüntüdeki her pikselin bir sınıfa atanmasıdır. Nesne tespitinden farklı olarak yalnızca bir gölün çevresine kutu çizmez; gölün kapladığı pikselleri belirler. Burada problemi denetimli piksel sınıflandırması olarak ele alacağız.

Her piksel, farklı dalga boylarında ölçülen yansıtımlardan oluşan bir özellik vektörüdür. Model, etiketlenmiş örneklerle bu ölçümler arasındaki ilişkileri öğrenir. Random Forest, birçok karar ağacının oylarını birleştirir; böylece tek bir ağacın ezberleme eğilimini azaltır. Ancak komşuluk ilişkilerini doğrudan modellemez, dolayısıyla sonuçta küçük benekler oluşabilir.

Önce veriyi doğru hazırlayalım

Örneğimiz, Sentinel-2 yüzey yansıtımı verilerinden hazırlanmış dört bantlı bir GeoTIFF kullanıyor. Bant sırası B2, B3, B4, B8, yani mavi, yeşil, kırmızı ve yakın kızılötesi olmalı. Bunlar doğal olarak 10 metre çözünürlüklüdür.

Bulutları ve gölgeleri kalite maskesiyle önceden dışlayın; dışlanan pikselleri NoData olarak kaydedin. Yansıtım ölçeğini ve varsa ofsetleri ürün metadatasından uygulayın. Aşağıdaki kod, bu işlemler tamamlanmış gerçek yansıtım değerlerini bekliyor; ham tamsayı ürünler için doğrudan kullanılmamalı.

Eğitim etiketleri aynı koordinat sisteminde, piksel boyutunda ve ızgarada bulunmalı. etiket.tif içinde 1=orman, 2=şehir, 3=su, 0=etiketsiz kullanacağız. Referansları arazi gözlemleri veya güvenilir haritalardan oluşturabilirsiniz.

İki küçük indeks, büyük yardım

Bitki örtüsünü belirginleştiren NDVI ve suyu vurgulayan NDWI şöyle hesaplanır:

Sağlıklı bitkiler kırmızı ışığı soğururken yakın kızılötesini güçlü yansıtır. Su ise yakın kızılötesinde genellikle koyudur. İndeksler bu karşıtlıkları sıkıştırılmış özelliklere dönüştürür. Yine de tek bir eşik evrensel çözüm değildir; mevsim, bulanıklık ve yüzey türleri değerleri değiştirir.

Python ile sınıflandırma

numpy, rasterio ve scikit-learn paketlerini kurduktan sonra aşağıdaki akışı kullanabilirsiniz. Etiketleriniz birden fazla uzamsal bloğa yayılmalı; eğitim bölümünde üç sınıf da temsil edilmelidir.

import numpy as np
import rasterio
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GroupShuffleSplit
from sklearn.metrics import classification_report

with rasterio.open("sentinel.tif") as src, rasterio.open("etiket.tif") as ref:
    if src.shape != ref.shape or src.crs != ref.crs or src.transform != ref.transform:
        raise ValueError("Görüntü ve etiket ızgaraları eşleşmiyor.")
    bands = src.read([1, 2, 3, 4], masked=True).astype("float32").filled(np.nan)
    labels = ref.read(1, masked=True).filled(0)
    profile = src.profile.copy()

blue, green, red, nir = bands
ndvi = (nir - red) / (nir + red + 1e-6)
ndwi = (green - nir) / (green + nir + 1e-6)
features = np.stack([blue, green, red, nir, ndvi, ndwi], axis=-1)
valid = np.isfinite(features).all(axis=-1)
training = valid & np.isin(labels, [1, 2, 3])

rows, cols = np.nonzero(training)
blocks_per_row = (labels.shape[1] + 255) // 256
groups = (rows // 256) * blocks_per_row + cols // 256
X, y = features[training], labels[training]
splitter = GroupShuffleSplit(n_splits=1, test_size=0.25, random_state=42)
train_idx, test_idx = next(splitter.split(X, y, groups))

if set(np.unique(y[train_idx])) != {1, 2, 3}:
    raise ValueError("Eğitim bölümünde bütün sınıflar bulunmalı.")

model = RandomForestClassifier(
    n_estimators=200, class_weight="balanced", n_jobs=-1, random_state=42
)
model.fit(X[train_idx], y[train_idx])
print(classification_report(
    y[test_idx], model.predict(X[test_idx]),
    labels=[1, 2, 3], target_names=["orman", "şehir", "su"], zero_division=0
))

segmentation = np.zeros(labels.shape, dtype="uint8")
segmentation[valid] = model.predict(features[valid])
profile.update(count=1, dtype="uint8", nodata=0, compress="lzw")
with rasterio.open("segmentasyon.tif", "w", **profile) as dst:
    dst.write(segmentation, 1)

Kod, dört bant ile iki indeksi birleştirir, modeli eğitir ve coğrafi referansı korunmuş bir sınıf haritası üretir. Küçük görüntüler için uygundur; büyük sahnelerde bellek tüketimini azaltmak amacıyla pencere bazlı okuma ve tahmin yapılmalıdır.

Güzel harita, güvenilir sonuç mu?

Rastgele piksel ayırmak, birbirine benzeyen komşuları hem eğitim hem teste taşıyabilir. Bloklarla ayırma daha gerçekçidir; blok sınırlarında tampon bırakmak değerlendirmeyi güçlendirir. Sınıf bazlı F1 değerlerini inceleyin: yüksek toplam doğruluk, az bulunan su alanlarının başarısızlığını gizleyebilir.

Son olarak, bu model her geçerli pikseli üç sınıftan birine zorlar. Tarla, kar veya çıplak toprak varsa ek sınıflar tanımlayın. Haritayı QGIS üzerinde referanslarla karşılaştırın; piksel dedektifinizin gerçekten doğru iz sürdüğünü kontrol edin!

Python’da bir jeneratörü ilk döngüde gezersiniz, her şey harika çalışır. Aynı nesneyi ikinci döngüye soktuğunuzda ise ne sonuç vardır ne hata mesajı. Program sanki kahve molasına çıkmıştır! Aslında burada bir arıza yoktur: Jeneratörler, tüketildikçe ilerleyen ve kendiliğinden başa dönmeyen iterator nesneleridir. Gelin bu sessizliğin arkasındaki mekanizmayı inceleyelim.

``

Iterable ile Iterator Aynı Şey Değildir

Bir iterable, üzerinden iterator elde edilebilen nesnedir. Liste bunun tanıdık örneğidir: iter(liste) çağrısı, baştan başlayabilen yeni bir iterator oluşturur. Listenin kendisi, dolaşım konumunu tutmaz; bu görev iterator’a aittir.

Bir iterator ise sıradaki öğenin hangisi olduğunu hatırlar. next() çağrıldığında ilerler; öğeler bittiğinde StopIteration yükseltir. Iterator üzerinde iter() çağrısı, aynı nesneyi döndürür. Dolayısıyla yeni bir döngü, yeni bir başlangıç konumu yaratmaz.

Jeneratör de bir iterator’dır. yield, fonksiyonun yürütülmesini askıya alır; sonraki next() çağrısı yürütmeyi kaldığı yerden sürdürür. Bunu kitaplıktan çok yürüyen bant gibi düşünün: Banttan aldığınız kutu, sonraki turda yeniden önünüze gelmez.

Sessiz Boşluğun Küçük Bir Gösterisi

Aşağıdaki fonksiyon, kareleri talep geldikçe üretir. Fonksiyonu çağırmak bütün kareleri hesaplamaz; çalıştırılmayı bekleyen bir jeneratör oluşturur:

def kareler(sinir):
    for sayi in range(sinir):
        yield sayi ** 2

g = kareler(3)

for deger in g:
    print("İlk tur:", deger)

for deger in g:
    print("İkinci tur:", deger)

print(next(g, "Tükendi"))

İlk döngü 0, 1 ve 4 değerlerini yazdırır. İkinci döngünün gövdesi hiç çalışmaz. Son satır ise Tükendi yazar; çünkü next() için bir varsayılan değer verdik.

Peki neden hata yok? for, iterator’dan değer isterken gelen StopIteration sinyalini normal bitiş olarak yorumlar. Bu sinyal kullanıcıya hata olarak gösterilmez. Varsayılan değer olmadan next(g) çağırırsanız, aynı durum açıkça bir istisna olarak görünür. Yani sessizlik, döngü protokolünün tasarlanmış davranışıdır.

Tek Kullanımlılık Bir Kusur Değil, Tercihtir

Jeneratörler, tüm sonuçları bellekte saklamak zorunda kalmadan hesaplama yapmayı sağlar. Yukarıdaki gibi yalnızca sınırlı durum tutan bir üreticide, $n$ sonuç için yaklaşık ek bellek karşılaştırması şöyledir:

Bu karşılaştırma, üretilen öğelerin boyutunu sabit kabul eder. Her jeneratörün toplam bellek tüketimi sabit değildir: İçeride büyük bir liste oluşturuyorsa veya kaynak veriyi bellekte tutuyorsa maliyet değişir. Kazanç, jeneratör etiketinden değil, gerçekten tembel üretim yapmaktan gelir.

Tekrar Dolaşmak İçin Doğru Strateji

İki temel seçenek vardır: Hesaplamayı yeniden başlatmak veya sonuçları saklamak.

def yeni_akis():
    return kareler(3)

for _ in range(2):
    print(list(yeni_akis()))

degerler = list(yeni_akis())
print(sum(degerler), max(degerler))

İlk bölüm, her turda yeni bir jeneratör oluşturur. İkinci bölüm, sonuçları bir kez listeye alır ve farklı işlemlerde tekrar kullanır. Listeye dönüştürmeyi jeneratör tükenmeden yapmalısınız; boş jeneratörden dolu liste çıkmaz!

Kaynak zamanla değişiyorsa, yeniden üretimin aynı değerleri vereceği de garanti değildir. Dosya, ağ veya rastgelelik içeren akışlarda bu ayrım önemlidir.

tee() Sihirli Bir Fotokopi Makinesi Değildir

İki tüketici aynı akışı farklı hızlarda okuyacaksa tee() kullanılabilir:

from itertools import tee

ilk, ikinci = tee(kareler(3), 2)
print(list(ilk))
print(list(ikinci))

İki iterator aynı değerleri görür; fakat geride kalan tüketici için öğeler tamponda tutulur. Biri çok ilerlerse bellek kullanımı büyüyebilir. Bölme işleminden sonra özgün iterator yerine döndürülen iterator’ları kullanın.

Son Tuzak: Kısmen Tüketmek

“Bir kez tüketilir” ifadesi, ilk döngü başladıktan sonra her şeyin kaybolduğu anlamına gelmez. Döngüden break ile çıkarsanız, sonraki döngü kalan öğelerden devam eder. sum() akışı tamamen tüketirken, any() uygun değeri bulunca durabilir. Hata ayıklarken çağırdığınız list(g) bile akışı bitirebilir.

Kısacası jeneratör bir koleksiyon değil, ilerleyen bir süreçtir. İkinci tur gerekiyorsa önce karar verin: Yeniden üretecek misiniz, saklayacak mısınız, yoksa tüketicileri ayıracak mısınız?

``

Önce mantık: SIR modeli

En yaygın başlangıç modellerinden biri SIR modelidir. Toplumu üç gruba ayırır:

• S — Duyarlı: Hastalığa yakalanabilecek kişiler.
• I — Bulaştırıcı: Hastalığı başkalarına aktarabilen kişiler.
• R — İyileşmiş: Bu modelde artık bulaştırmayan ve yeniden enfekte olmayan kişiler.

Doğum, ölüm ve göçü dışarıda bırakırsak toplam nüfus sabittir: $N=S+I+R$. İnsanlar önce S grubundan I grubuna, ardından R grubuna geçer. Bu, herkesin birbirine benzer olasılıkla temas ettiği varsayılan bir modeldir; gerçek hayattaki arkadaş çevreleri ve okul koridorları şimdilik sahne dışında kalır.

Modelin iki temel parametresi vardır. $\beta$, bulaşmayı belirleyen etkin temas hızıdır; $\gamma$ ise iyileşme hızıdır. İkisi de zamanın tersi birimine sahiptir. Sabit iyileşme hızı varsayımında ortalama bulaştırıcılık süresi $1/\gamma$ olur.

Bu denklemler, grupların değişim hızını anlatır. Yeni enfeksiyonlar hem duyarlı hem bulaştırıcı kişiler bulunduğunda oluşur; iyileşmeler ise bulaştırıcı grubunu küçültür.

Tamamen duyarlı bir toplumda temel üreme sayısı $R_0=\beta/\gamma$ olarak hesaplanır. Örneğin $\beta=0.3$ ve $\gamma=0.1$ için $R_0=3$ çıkar. Fakat duyarlı nüfus azaldıkça etkin üreme sayısı $R_e=R_0S/N$ düşer. Bu modelde $R_e<1$ olduğunda bulaştırıcı sayısının azalma eğilimi beklenir.

Hangi model, hangi soru?

Denklemleri doğrudan çözmek düzgün eğriler üretir. Olasılıksal simülasyonda ise günlük sayılar dalgalanır. Özellikle başlangıçta az sayıda bulaştırıcı varsa, aynı parametrelerle bazı salgınlar büyüyebilir, bazıları erken sönebilir. Rastgelelik burada süs değil, modelin önemli bir parçasıdır.

Python ile olasılıksal simülasyon

Aşağıdaki örnekte her adım çeyrek gündür. Bir duyarlı kişinin enfekte olma olasılığını $p=1-e^{-\beta(I/N)\Delta t}$, bir bulaştırıcının iyileşme olasılığını ise $q=1-e^{-\gamma\Delta t}$ olarak hesaplıyoruz. Ardından binom dağılımından geçiş sayıları çekiyoruz. NumPy için pip install numpy yeterlidir.

import numpy as np

rng = np.random.default_rng(42)
N = 10_000
S, I, R = N - 10, 10, 0
beta, gamma, dt = 0.3, 0.1, 0.25
history = [(0.0, S, I, R)]

for step in range(1, int(120 / dt) + 1):
    p_infection = 1 - np.exp(-beta * I / N * dt)
    p_recovery = 1 - np.exp(-gamma * dt)

    infections = rng.binomial(S, p_infection)
    recoveries = rng.binomial(I, p_recovery)

    S -= infections
    I += infections - recoveries
    R += recoveries

    assert S + I + R == N
    assert min(S, I, R) >= 0
    history.append((step * dt, S, I, R))

peak = max(history, key=lambda row: row[2])
print("Zirve günü:", peak[0])
print("Zirvedeki bulaştırıcı sayısı:", peak[2])

Geçişler adımın başındaki sayılardan hesaplanır; yeni enfekte olanlar aynı adımda iyileşmez. Bu, sürekli zamanlı sürecin ayrık zaman yaklaşımıdır. Daha küçük adımlar genellikle yaklaşımı iyileştirir, fakat hesaplama yükünü artırır. Sabit rastgelelik tohumu sonucu tekrarlanabilir kılar; assert ifadeleri de nüfus muhasebesini denetler.

Deney tasarlamak, tek eğriden değerlidir

Şimdi sanal laboratuvarın düğmeleriyle oynayabiliriz:

• Temasları azalt: Belirli bir günden sonra $\beta$ değerini düşür; zirvenin yüksekliğini ve zamanını karşılaştır.
• Başlangıç bağışıklığını değiştir: Kusursuz koruma varsayımıyla bazı kişileri başlangıçta R grubuna yerleştir.
• Tekrarlı koşular yap: Farklı tohumlarla yüzlerce simülasyon çalıştır; yalnızca ortalamayı değil, yüzdelik aralıkları da raporla.

Zirvedeki bulaştırıcı sayısı, toplam enfekte olan kişi sayısıyla aynı değildir. Ayrıca daha alçak bir zirve, salgının daha kısa süreceği anlamına gelmez. Ölçütü araştırma sorusuna göre seçmek gerekir.

Modelin sınırlarını unutma

Buradaki sayılar varsayımsaldır. Yaş, davranış değişimi, mevsimsellik, yeniden enfeksiyon ve eksik bildirim sonuçları değiştirebilir. Gerçek verilerle çalışırken parametre tahmini, duyarlılık analizi ve bağımsız doğrulama gerekir. İyi simülasyon kesinlik satmaz; varsayımlar açıkça belirtilirse, hangi koşullarda hangi sonuçların mümkün olduğunu anlamamıza yardım eder.