<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="4.4.1">Jekyll</generator><link href="https://program.sonsuz.us/feed.xml" rel="self" type="application/atom+xml" /><link href="https://program.sonsuz.us/" rel="alternate" type="text/html" /><updated>2026-11-03T00:06:03+00:00</updated><id>https://program.sonsuz.us/feed.xml</id><title type="html">SonsuzUs</title><subtitle>Programlama ve Yazılım</subtitle><author><name>Sonsuz Us</name></author><entry><title type="html">AlphaGo ve Pekiştirmeli Öğrenme: Yapay Zekâ Go Tahtasında Nasıl Ustalaştı?</title><link href="https://program.sonsuz.us/posts/alphago-ve-pekistirmeli-ogrenme-yapay-zeka-go-tahtasinda-nasil-ustalasti/" rel="alternate" type="text/html" title="AlphaGo ve Pekiştirmeli Öğrenme: Yapay Zekâ Go Tahtasında Nasıl Ustalaştı?" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/alphago-ve-pekistirmeli-ogrenme-yapay-zeka-go-tahtasinda-nasil-ustalasti</id><content type="html" xml:base="https://program.sonsuz.us/posts/alphago-ve-pekistirmeli-ogrenme-yapay-zeka-go-tahtasinda-nasil-ustalasti/"><![CDATA[<p>Bir bilgisayarın Go tahtasında dünya şampiyonuna meydan okuması, yalnızca hızlı hesaplama meselesi değildi. Asıl devrim, deneyimden öğrenmek ve kendi hatalarını yeni derslere dönüştürmekti. AlphaGo bu dönüşümün simgesi oldu; AlphaGo Zero ise insan oyunlarını başlangıç noktası olarak kullanmadan aynı yolculuğu daha ileri taşıdı. Peki bu dijital ustalık nasıl doğdu?</p>

<p><img src="/img/alphago-ve-pekistirmeli-78.svg" alt="alphago-ve-pekistirmeli-78" /></p>

<p>``</p>

<h2 id="go-neden-böylesine-zor">Go neden böylesine zor?</h2>

<p>Go, siyah ve beyaz taşlarla alan kontrolü kurmaya dayanan bir strateji oyunudur. Kurallar görece basittir, ancak 19×19 tahtadaki olası yasal konumların sayısı yaklaşık $10^{170}$ mertebesindedir. Bütün olasılıkları taramak, okyanusu çay kaşığıyla boşaltmaya benzer.</p>

<p>Üstelik iyi bir hamle hemen ödül getirmeyebilir. Bugün yapılan küçük bir fedakârlık, onlarca hamle sonra büyük bir bölge kazandırabilir. Dolayısıyla sistemin yalnızca mevcut taşları değil, gelecekteki sonuçları değerlendirmesi gerekir.</p>

<h2 id="pekiştirmeli-öğrenmenin-temel-mantığı">Pekiştirmeli öğrenmenin temel mantığı</h2>

<p>Pekiştirmeli öğrenmede bir <strong>ajan</strong>, çevreyle etkileşerek karar vermeyi öğrenir. Go için durum $s$ tahta konumunu, eylem $a$ taş yerleştirmeyi veya pas geçmeyi temsil eder. Politika $\pi(a\vert s)$, hangi durumda hangi hamlenin seçileceğini belirler.</p>

<p>Amaç, beklenen toplam ödülü büyütmektir:</p>

\[J(\theta)=\mathbb{E}_{\pi_\theta}\left[\sum_{t=0}^{T}\gamma^t r_t\right]\]

<p>Burada $\theta$ model parametreleri, $r_t$ ödül, $\gamma$ gelecekteki ödüllerin ağırlığıdır. Sonlu Go karşılaşmalarında $\gamma=1$ kullanılabilir. Basitleştirilmiş bir düzende ara hamleler ödülsüzdür; sonuç, ilgili oyuncunun açısından galibiyette $+1$, yenilgide $-1$ olur.</p>

<table>
  <thead>
    <tr>
      <th>Kavram</th>
      <th>Go karşılığı</th>
      <th>Öğrenmedeki görevi</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Durum</td>
      <td>Tahta ve oyun bağlamı</td>
      <td>Karara temel sağlar</td>
    </tr>
    <tr>
      <td>Politika</td>
      <td>Hamle olasılıkları</td>
      <td>Aday hamleleri önerir</td>
    </tr>
    <tr>
      <td>Değer</td>
      <td>Beklenen oyun sonucu</td>
      <td>Konumun geleceğini değerlendirir</td>
    </tr>
    <tr>
      <td>Ödül</td>
      <td>Maç sonucu</td>
      <td>Öğrenmenin hedefini belirler</td>
    </tr>
  </tbody>
</table>

<h2 id="alphago-ile-alphago-zero-aynı-şey-değil">AlphaGo ile AlphaGo Zero aynı şey değil</h2>

<p>2016’da Lee Sedol’u 4–1 yenen AlphaGo, önce insan uzmanların oyunlarından öğrenmişti. Ardından kendi kendine oynayarak politikasını geliştirdi; değer ağı da öz-oyun verilerinden yararlandı. Yani orijinal başarıyı tamamen insan verisinden bağımsızmış gibi anlatmak yanlış olur.</p>

<p>2017’de tanıtılan AlphaGo Zero ise insan oyunlarını kullanmadan, oyun kuralları ve öz-oyun üzerinden öğrendi. Politika ve değer tahminlerini tek sinir ağında birleştirdi.</p>

<table>
  <thead>
    <tr>
      <th>Özellik</th>
      <th>AlphaGo</th>
      <th>AlphaGo Zero</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Başlangıç verisi</td>
      <td>İnsan oyunları</td>
      <td>İnsan oyunları yok</td>
    </tr>
    <tr>
      <td>Ağ yapısı</td>
      <td>Ayrı politika ve değer ağları</td>
      <td>Birleşik politika-değer ağı</td>
    </tr>
    <tr>
      <td>Gelişim</td>
      <td>İnsan verisi ve öz-oyun</td>
      <td>Öz-oyun</td>
    </tr>
  </tbody>
</table>

<h2 id="arama-sezgiyi-nasıl-güçlendirir">Arama, sezgiyi nasıl güçlendirir?</h2>

<p>Sinir ağı tek başına son sözü söylemez. <strong>Monte Carlo Ağaç Araması</strong>, yani MCTS, aday hamlelerin devamlarını araştırır. Politika tahmini aramayı umut verici dallara yönlendirirken değer tahmini ulaşılan konumları değerlendirir.</p>

<p>Arama, daha önce başarılı görünen hamleleri kullanmak ile yeterince incelenmemiş hamleleri keşfetmek arasında denge kurar. Sonunda ziyaret sayılarından bir hamle dağılımı elde edilir. Ağın ilk önerisi böylece aramayla iyileştirilir; bu dağılım, sonraki eğitimin hedefi olur. Öğrenci kendi analizlerinden ders çıkarır!</p>

<h2 id="python-ile-öz-oyun-iskeleti">Python ile öz-oyun iskeleti</h2>

<p>Aşağıdaki kod, hazır bir Go ortamı ve MCTS ajanı varsayar. Tam AlphaGo uygulaması değildir; eğitim örneklerinin nasıl toplandığını gösterir. <code class="language-plaintext highlighter-rouge">search</code>, pas dâhil yasal hamleler üzerinde normalize edilmiş olasılıklar döndürmelidir.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">numpy</span> <span class="k">as</span> <span class="n">np</span>


<span class="k">def</span> <span class="nf">self_play</span><span class="p">(</span><span class="n">env</span><span class="p">,</span> <span class="n">agent</span><span class="p">):</span>
    <span class="n">env</span><span class="p">.</span><span class="nf">reset</span><span class="p">()</span>
    <span class="n">history</span> <span class="o">=</span> <span class="p">[]</span>

    <span class="k">while</span> <span class="ow">not</span> <span class="n">env</span><span class="p">.</span><span class="n">done</span><span class="p">:</span>
        <span class="n">player</span> <span class="o">=</span> <span class="n">env</span><span class="p">.</span><span class="n">current_player</span>  <span class="c1"># +1 veya -1
</span>        <span class="n">state</span> <span class="o">=</span> <span class="n">env</span><span class="p">.</span><span class="nf">canonical_state</span><span class="p">().</span><span class="nf">copy</span><span class="p">()</span>
        <span class="n">policy</span> <span class="o">=</span> <span class="n">agent</span><span class="p">.</span><span class="nf">search</span><span class="p">(</span><span class="n">env</span><span class="p">)</span>
        <span class="n">history</span><span class="p">.</span><span class="nf">append</span><span class="p">((</span><span class="n">state</span><span class="p">,</span> <span class="n">policy</span><span class="p">.</span><span class="nf">copy</span><span class="p">(),</span> <span class="n">player</span><span class="p">))</span>

        <span class="n">action</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="n">random</span><span class="p">.</span><span class="nf">choice</span><span class="p">(</span>
            <span class="n">env</span><span class="p">.</span><span class="n">action_size</span><span class="p">,</span> <span class="n">p</span><span class="o">=</span><span class="n">policy</span>
        <span class="p">)</span>
        <span class="n">env</span><span class="p">.</span><span class="nf">step</span><span class="p">(</span><span class="n">action</span><span class="p">)</span>

    <span class="n">winner</span> <span class="o">=</span> <span class="n">env</span><span class="p">.</span><span class="nf">winner</span><span class="p">()</span>  <span class="c1"># +1, -1 veya beraberlikte 0
</span>    <span class="k">return</span> <span class="p">[</span>
        <span class="p">(</span><span class="n">state</span><span class="p">,</span> <span class="n">policy</span><span class="p">,</span> <span class="nf">float</span><span class="p">(</span><span class="n">winner</span> <span class="o">*</span> <span class="n">player</span><span class="p">))</span>
        <span class="k">for</span> <span class="n">state</span><span class="p">,</span> <span class="n">policy</span><span class="p">,</span> <span class="n">player</span> <span class="ow">in</span> <span class="n">history</span>
    <span class="p">]</span>
</code></pre></div></div>

<p>Her kayıt, bir konumu, aramanın hamle dağılımını ve o konumdaki oyuncunun sonucunu saklar. <code class="language-plaintext highlighter-rouge">canonical_state</code>, tahtayı sıradaki oyuncunun bakış açısından kodlar. Sonucun oyuncuyla çarpılması önemlidir: aynı maç, kazanan için olumlu, kaybeden için olumsuz örnektir.</p>

<h2 id="deneyimden-ustalığa">Deneyimden ustalığa</h2>

<p>AlphaGo Zero yaklaşımında eğitim kaybı üç parçayı birleştirir:</p>

\[L=(z-v)^2-\sum_a\pi(a)\log p(a)+c\lVert\theta\rVert^2\]

<p>İlk terim değer tahminini gerçek sonuca yaklaştırır. İkinci terim ağ politikasını MCTS dağılımına yaklaştırır. Son terim ağırlıkları düzenler. Oyunlar üretildikçe ağ güncellenir, güçlenen ağ daha kaliteli aramalar yapar ve döngü sürer.</p>

<p>Ancak başarı sınırsız değildir: Go’nun kuralları açık, sonuçları ölçülebilirdir ve deneyim üretmek hesaplama ister. AlphaGo’nun dersi, bütün problemleri çözen sihirli bir formül değil; <strong>öğrenme, arama ve geri bildirimin birlikte insan uzmanlığını aşabilecek kadar güçlü olabilmesidir</strong>.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="alphago" /><category term="pekiştirmeli öğrenme" /><category term="yapay zekâ" /><category term="go" /><category term="derin öğrenme" /><category term="mcts" /><summary type="html"><![CDATA[Bir bilgisayarın Go tahtasında dünya şampiyonuna meydan okuması, yalnızca hızlı hesaplama meselesi değildi. Asıl devrim, deneyimden öğrenmek ve kendi hatalarını yeni derslere dönüştürmekti. AlphaGo bu dönüşümün simgesi oldu; AlphaGo Zero ise insan oyunlarını başlangıç noktası olarak kullanmadan aynı yolculuğu daha ileri taşıdı. Peki bu dijital ustalık nasıl doğdu?]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/alphago-ve-pekistirmeli-78.png" /><media:content medium="image" url="https://program.sonsuz.us/img/alphago-ve-pekistirmeli-78.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Çapraz Sevkiyat Yazılımları: Depoyu Bekleme Salonundan Aktarma Merkezine Dönüştürmek</title><link href="https://program.sonsuz.us/posts/capraz-sevkiyat-yazilimlari-depoyu-bekleme-salonundan-aktarma-merkezine-donusturmek/" rel="alternate" type="text/html" title="Çapraz Sevkiyat Yazılımları: Depoyu Bekleme Salonundan Aktarma Merkezine Dönüştürmek" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/capraz-sevkiyat-yazilimlari-depoyu-bekleme-salonundan-aktarma-merkezine-donusturmek</id><content type="html" xml:base="https://program.sonsuz.us/posts/capraz-sevkiyat-yazilimlari-depoyu-bekleme-salonundan-aktarma-merkezine-donusturmek/"><![CDATA[<p>Bir kamyon depoya yanaşıyor, paletler indiriliyor ve ürünler raflara yerleşmeden başka bir kamyona yükleniyor. Kulağa lojistik sihirbazlığı gibi geliyor, değil mi? Çapraz sevkiyat, yani cross-docking, tam olarak bu akışı hedefler. Ancak gösterinin yıldızı forklift değil; doğru ürünü, doğru zamanda, doğru çıkış aracına yönlendiren yazılımdır.
``</p>

<h2 id="temel-mantık-depolamak-yerine-akışı-yönetmek">Temel Mantık: Depolamak Yerine Akışı Yönetmek</h2>

<p>Geleneksel depolamada ürün kabul edilir, stok alanına taşınır, sipariş geldiğinde toplanır ve sevk edilir. Çapraz sevkiyatta ise gelen ürünün çıkış planı mümkün olduğunca önceden bellidir. Yazılım, giriş sevkiyatlarını müşteri siparişleriyle veya dağıtım noktalarıyla eşleştirir.</p>

<p>Buradaki “bekletilmeden” ifadesi mutlak sıfır bekleme anlamına gelmez. Kontrol, ayrıştırma ve araç senkronizasyonu için kısa süreli tampon alanlar gerekebilir. Amaç, uzun süreli stoklamayı ortadan kaldırmaktır. Bazı operasyonlarda palet doğrudan aktarılırken bazılarında koliler farklı mağazalar için yeniden gruplanır.</p>

<table>
  <thead>
    <tr>
      <th>Boyut</th>
      <th>Geleneksel depo</th>
      <th>Çapraz sevkiyat</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Ana odak</td>
      <td>Stok yönetimi</td>
      <td>Zaman ve akış yönetimi</td>
    </tr>
    <tr>
      <td>Ürün hareketi</td>
      <td>Raflama ve toplama</td>
      <td>Ayrıştırma ve aktarma</td>
    </tr>
    <tr>
      <td>Kritik bilgi</td>
      <td>Stok konumu</td>
      <td>Varış ve kalkış zamanı</td>
    </tr>
    <tr>
      <td>Temel risk</td>
      <td>Stok doğruluğu hatası</td>
      <td>Bağlantının kaçırılması</td>
    </tr>
  </tbody>
</table>

<h2 id="teorik-altyapı-bir-eşleştirme-ve-çizelgeleme-problemi">Teorik Altyapı: Bir Eşleştirme ve Çizelgeleme Problemi</h2>

<p>Operasyon, iki taraflı bir eşleştirme problemi gibi düşünülebilir: Bir tarafta gelen ürün partileri, diğer tarafta çıkış araçları vardır. Fakat hedef adresin uyuşması tek başına yetmez. Araç kapasitesi, yükleme süresi, kapı müsaitliği ve ürünün sıcaklık gereksinimi de hesaba katılmalıdır.</p>

<p>Basitleştirilmiş bir optimizasyon hedefi şöyle yazılabilir:</p>

\[\min C = \alpha \sum_i W_i + \beta \sum_i L_i\]

<p>Burada $W_i$ partinin aktarmaya hazır olduktan sonraki bekleme süresi, $L_i$ ise hedeflenen çıkış zamanına göre gecikmesidir. $\alpha$ ve $\beta$, bu süreleri ortak bir maliyet ölçeğine dönüştüren ağırlıklardır. Gecikmenin ticari bedeli yüksekse ikinci ağırlık artırılır. Ancak kapasite ve güvenlik gibi sert kısıtlar, maliyet düşsün diye ihlal edilemez.</p>

<h2 id="yazılım-sahada-nasıl-çalışır">Yazılım Sahada Nasıl Çalışır?</h2>

<p><strong>Ön bildirim:</strong> Tedarikçiden ASN, yani ön sevkiyat bildirimi alınır. Ürün, miktar, taşıma birimi ve tahmini varış bilgileri sisteme girer.</p>

<p><strong>Planlama:</strong> WMS depo içi hareketleri, TMS ise taşıma planını yönetir. Entegrasyon katmanı bunları birleştirerek ürünleri uygun çıkış seferlerine ve aktarma kapılarına atar.</p>

<p><strong>Doğrulama:</strong> Kabul sırasında barkod veya RFID okutulur. Beklenen miktarla fiziksel miktar karşılaştırılır; eksik, hasarlı ya da yanlış ürünler istisna akışına alınır.</p>

<p><strong>Yönlendirme:</strong> El terminali operatöre aktarım alanını gösterir. Yükleme okutması tamamlanınca sevkiyat kaydı güncellenir ve ilgili sistemlere olay gönderilir. Böylece dijital planın sahada gerçekten uygulanıp uygulanmadığı anlaşılır.</p>

<h2 id="python-ile-küçük-bir-planlayıcı">Python ile Küçük Bir Planlayıcı</h2>

<p>Aşağıdaki örnek, hazır partileri aynı hedefe giden, zaman penceresine uyan ve yeterli ağırlık kapasitesi bulunan araçlara atar. <code class="language-plaintext highlighter-rouge">hazir</code>, <code class="language-plaintext highlighter-rouge">kalkis</code> ve <code class="language-plaintext highlighter-rouge">son_kalkis</code> değerleri aynı zaman dilimindeki <code class="language-plaintext highlighter-rouge">datetime</code> nesneleri olmalıdır.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">eslestir</span><span class="p">(</span><span class="n">partiler</span><span class="p">,</span> <span class="n">araclar</span><span class="p">):</span>
    <span class="n">kalan</span> <span class="o">=</span> <span class="p">{</span><span class="n">a</span><span class="p">[</span><span class="sh">"</span><span class="s">id</span><span class="sh">"</span><span class="p">]:</span> <span class="n">a</span><span class="p">[</span><span class="sh">"</span><span class="s">kapasite_kg</span><span class="sh">"</span><span class="p">]</span> <span class="k">for</span> <span class="n">a</span> <span class="ow">in</span> <span class="n">araclar</span><span class="p">}</span>
    <span class="n">plan</span><span class="p">,</span> <span class="n">istisnalar</span> <span class="o">=</span> <span class="p">[],</span> <span class="p">[]</span>

    <span class="k">for</span> <span class="n">parti</span> <span class="ow">in</span> <span class="nf">sorted</span><span class="p">(</span><span class="n">partiler</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="k">lambda</span> <span class="n">p</span><span class="p">:</span> <span class="n">p</span><span class="p">[</span><span class="sh">"</span><span class="s">hazir</span><span class="sh">"</span><span class="p">]):</span>
        <span class="n">uygun</span> <span class="o">=</span> <span class="p">[</span>
            <span class="n">a</span> <span class="k">for</span> <span class="n">a</span> <span class="ow">in</span> <span class="n">araclar</span>
            <span class="k">if</span> <span class="n">a</span><span class="p">[</span><span class="sh">"</span><span class="s">hedef</span><span class="sh">"</span><span class="p">]</span> <span class="o">==</span> <span class="n">parti</span><span class="p">[</span><span class="sh">"</span><span class="s">hedef</span><span class="sh">"</span><span class="p">]</span>
            <span class="ow">and</span> <span class="n">parti</span><span class="p">[</span><span class="sh">"</span><span class="s">hazir</span><span class="sh">"</span><span class="p">]</span> <span class="o">&lt;=</span> <span class="n">a</span><span class="p">[</span><span class="sh">"</span><span class="s">kalkis</span><span class="sh">"</span><span class="p">]</span> <span class="o">&lt;=</span> <span class="n">parti</span><span class="p">[</span><span class="sh">"</span><span class="s">son_kalkis</span><span class="sh">"</span><span class="p">]</span>
            <span class="ow">and</span> <span class="n">kalan</span><span class="p">[</span><span class="n">a</span><span class="p">[</span><span class="sh">"</span><span class="s">id</span><span class="sh">"</span><span class="p">]]</span> <span class="o">&gt;=</span> <span class="n">parti</span><span class="p">[</span><span class="sh">"</span><span class="s">kg</span><span class="sh">"</span><span class="p">]</span>
        <span class="p">]</span>

        <span class="k">if</span> <span class="ow">not</span> <span class="n">uygun</span><span class="p">:</span>
            <span class="n">istisnalar</span><span class="p">.</span><span class="nf">append</span><span class="p">(</span><span class="n">parti</span><span class="p">[</span><span class="sh">"</span><span class="s">id</span><span class="sh">"</span><span class="p">])</span>
            <span class="k">continue</span>

        <span class="n">arac</span> <span class="o">=</span> <span class="nf">min</span><span class="p">(</span><span class="n">uygun</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="k">lambda</span> <span class="n">a</span><span class="p">:</span> <span class="n">a</span><span class="p">[</span><span class="sh">"</span><span class="s">kalkis</span><span class="sh">"</span><span class="p">])</span>
        <span class="n">kalan</span><span class="p">[</span><span class="n">arac</span><span class="p">[</span><span class="sh">"</span><span class="s">id</span><span class="sh">"</span><span class="p">]]</span> <span class="o">-=</span> <span class="n">parti</span><span class="p">[</span><span class="sh">"</span><span class="s">kg</span><span class="sh">"</span><span class="p">]</span>
        <span class="n">plan</span><span class="p">.</span><span class="nf">append</span><span class="p">((</span><span class="n">parti</span><span class="p">[</span><span class="sh">"</span><span class="s">id</span><span class="sh">"</span><span class="p">],</span> <span class="n">arac</span><span class="p">[</span><span class="sh">"</span><span class="s">id</span><span class="sh">"</span><span class="p">]))</span>

    <span class="k">return</span> <span class="n">plan</span><span class="p">,</span> <span class="n">istisnalar</span>
</code></pre></div></div>

<p>Bu, en erken uygun kalkışı seçen açgözlü bir sezgiseldir; küresel optimumu garanti etmez. <code class="language-plaintext highlighter-rouge">hazir</code> zamanı, gerekli kontrol ve hazırlık işlemlerinin tamamlanmasını temsil eder. Atanamayan partileri gizlemek yerine istisna listesinde döndürmesi önemlidir: Operatör alternatif sefer planlayabilir.</p>

<p>Gerçek sistemde hacim, palet pozisyonu, kapı çakışmaları ve yükleme süreleri de modellenmelidir. Daha karmaşık senaryolarda karma tamsayılı programlama veya kısıt programlama kullanılabilir.</p>

<h2 id="üretimde-asıl-sınav-gecikmeler-ve-veri-tutarlılığı">Üretimde Asıl Sınav: Gecikmeler ve Veri Tutarlılığı</h2>

<p>Giriş kamyonu geciktiğinde yazılım kalan bağlantıları yeniden değerlendirmelidir. Ancak her güncellemede bütün planı değiştirmek, sahayı dijital sandalye kapmacaya çevirebilir. Başlamış yüklemeleri sabitlemek ve yalnızca etkilenen partileri yeniden planlamak daha kontrollü bir yaklaşımdır.</p>

<p>Aynı barkodun tekrar okutulması stok hareketini iki kez oluşturmamalıdır. Olay kimlikleriyle idempotent işlem yapmak, eşzamanlı kapasite rezervasyonlarını veritabanı işlemleriyle korumak ve değişiklikleri denetim kaydına yazmak temel gereksinimlerdir.</p>

<p>Başarıyı ortalama bekleme süresi, zamanında çıkış oranı, yanlış yükleme oranı ve araç doluluğuyla ölçün. Yalnızca hızlanmak yetmez; yanlış kamyona hızlı yüklenen palet, sonuçta daha hızlı kaybolmuş sayılmaz. İyi çapraz sevkiyat yazılımı, hızı doğrulukla birlikte yönetir.</p>

<p><img src="/img/capraz-sevkiyat-yazilimlari-29.svg" alt="capraz-sevkiyat-yazilimlari-29" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Program" /><category term="çapraz sevkiyat" /><category term="cross-docking" /><category term="lojistik" /><category term="python" /><category term="wms" /><category term="tms" /><summary type="html"><![CDATA[Bir kamyon depoya yanaşıyor, paletler indiriliyor ve ürünler raflara yerleşmeden başka bir kamyona yükleniyor. Kulağa lojistik sihirbazlığı gibi geliyor, değil mi? Çapraz sevkiyat, yani cross-docking, tam olarak bu akışı hedefler. Ancak gösterinin yıldızı forklift değil; doğru ürünü, doğru zamanda, doğru çıkış aracına yönlendiren yazılımdır.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/capraz-sevkiyat-yazilimlari-29.png" /><media:content medium="image" url="https://program.sonsuz.us/img/capraz-sevkiyat-yazilimlari-29.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Çarpışma Tespiti: Oyun Dünyasının Görünmez Trafik Polisi</title><link href="https://program.sonsuz.us/posts/carpisma-tespiti-oyun-dunyasinin-gorunmez-trafik-polisi/" rel="alternate" type="text/html" title="Çarpışma Tespiti: Oyun Dünyasının Görünmez Trafik Polisi" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/carpisma-tespiti-oyun-dunyasinin-gorunmez-trafik-polisi</id><content type="html" xml:base="https://program.sonsuz.us/posts/carpisma-tespiti-oyun-dunyasinin-gorunmez-trafik-polisi/"><![CDATA[<p><img src="/img/carpisma-tespiti-oyun-43.svg" alt="carpisma-tespiti-oyun-43" /></p>

<p>Karakteriniz duvardan geçiyor, mermiler hedefi delmeden kayboluyor veya kutular birbirinin içine yerleşiyorsa, oyun dünyanızın trafik polisi biraz uyukluyor olabilir. Çarpışma tespiti, nesnelerin geometrik olarak temas edip etmediğini belirler. İşin püf noktası yalnızca doğru cevabı bulmak değil, bunu her karede binlerce nesne için yeterince hızlı yapabilmektir.</p>

<p>``</p>

<h2 id="önce-geometri-sonra-performans">Önce Geometri, Sonra Performans</h2>

<p>Bir nesnenin ekranda görünen şekliyle çarpışma geometrisi aynı olmak zorunda değildir. Karmaşık bir karakter modeli yerine daire, kutu veya kapsül kullanabilirsiniz. Bu temsil, hesaplama maliyetini düşürür; ancak görünür şekle göre yaklaşık sonuçlar üretebilir. Dolayısıyla ilk kararınız, oyunun ne kadar geometrik hassasiyet gerektirdiğidir.</p>

<p>Her nesneyi diğerleriyle karşılaştırırsanız test sayısı $n(n-1)/2$ olur. Bu, $O(n^2)$ büyüme demektir: nesne sayısını ikiye katlamak, iş yükünü yaklaşık dört katına çıkarır.</p>

<table>
  <thead>
    <tr>
      <th>Temsil</th>
      <th>Güçlü yanı</th>
      <th>Sınırlaması</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Daire / küre</td>
      <td>Hızlı mesafe testi</td>
      <td>Uzun nesnelerde kaba yaklaşım</td>
    </tr>
    <tr>
      <td>AABB</td>
      <td>Basit karşılaştırmalar</td>
      <td>Dönmüş nesnelerde boşluk bırakır</td>
    </tr>
    <tr>
      <td>Dışbükey çokgen</td>
      <td>Daha hassas sınırlar</td>
      <td>Daha fazla geometrik işlem</td>
    </tr>
  </tbody>
</table>

<h2 id="aabb-kutularla-hızlı-başlangıç">AABB: Kutularla Hızlı Başlangıç</h2>

<p><strong>Axis-Aligned Bounding Box</strong>, kenarları koordinat eksenlerine paralel bir sınırlayıcı kutudur. İki kutunun çarpışması için hem yatay hem dikey aralıklarının örtüşmesi gerekir. Bir eksende ayrılıyorlarsa, diğer eksene bakmadan sonucu söyleyebilirsiniz.</p>

<p>Aşağıdaki Python kodu, dünya koordinatlarındaki iki kutuyu test eder. Sınırların doğru sıralandığını, yani minimum değerlerin maksimumlardan büyük olmadığını varsayar:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="n">dataclasses</span> <span class="kn">import</span> <span class="n">dataclass</span>

<span class="nd">@dataclass</span><span class="p">(</span><span class="n">frozen</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
<span class="k">class</span> <span class="nc">AABB</span><span class="p">:</span>
    <span class="n">min_x</span><span class="p">:</span> <span class="nb">float</span>
    <span class="n">min_y</span><span class="p">:</span> <span class="nb">float</span>
    <span class="n">max_x</span><span class="p">:</span> <span class="nb">float</span>
    <span class="n">max_y</span><span class="p">:</span> <span class="nb">float</span>

<span class="k">def</span> <span class="nf">intersects</span><span class="p">(</span><span class="n">a</span><span class="p">:</span> <span class="n">AABB</span><span class="p">,</span> <span class="n">b</span><span class="p">:</span> <span class="n">AABB</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">bool</span><span class="p">:</span>
    <span class="n">separated_x</span> <span class="o">=</span> <span class="n">a</span><span class="p">.</span><span class="n">max_x</span> <span class="o">&lt;</span> <span class="n">b</span><span class="p">.</span><span class="n">min_x</span> <span class="ow">or</span> <span class="n">b</span><span class="p">.</span><span class="n">max_x</span> <span class="o">&lt;</span> <span class="n">a</span><span class="p">.</span><span class="n">min_x</span>
    <span class="n">separated_y</span> <span class="o">=</span> <span class="n">a</span><span class="p">.</span><span class="n">max_y</span> <span class="o">&lt;</span> <span class="n">b</span><span class="p">.</span><span class="n">min_y</span> <span class="ow">or</span> <span class="n">b</span><span class="p">.</span><span class="n">max_y</span> <span class="o">&lt;</span> <span class="n">a</span><span class="p">.</span><span class="n">min_y</span>
    <span class="k">return</span> <span class="ow">not</span> <span class="p">(</span><span class="n">separated_x</span> <span class="ow">or</span> <span class="n">separated_y</span><span class="p">)</span>

<span class="n">player</span> <span class="o">=</span> <span class="nc">AABB</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="n">wall</span> <span class="o">=</span> <span class="nc">AABB</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="nf">print</span><span class="p">(</span><span class="nf">intersects</span><span class="p">(</span><span class="n">player</span><span class="p">,</span> <span class="n">wall</span><span class="p">))</span>  <span class="c1"># True: kenarlar temas ediyor
</span></code></pre></div></div>

<p>Burada kenar teması çarpışma sayılır. Yalnızca pozitif alanlı örtüşme istiyorsanız ayırma karşılaştırmalarını <code class="language-plaintext highlighter-rouge">&lt;=</code> yapabilirsiniz. Bu küçük tercih, platform oyunlarında zeminde durma davranışını bile etkileyebilir!</p>

<h2 id="daireler-karekökü-emekliye-ayırın">Daireler: Karekökü Emekliye Ayırın</h2>

<p>İki dairenin merkezleri arasındaki uzaklık, yarıçaplarının toplamından büyük değilse daireler çarpışır. Ancak uzaklığı hesaplamak için karekök almak şart değildir:</p>

\[(x_1-x_2)^2 + (y_1-y_2)^2 \le (r_1+r_2)^2\]

<p>Her iki taraf da negatif olmadığından, karelerini karşılaştırmak eşdeğerdir. Böylece gereksiz karekök işleminden kaçınırsınız. Bu yöntem toplar, basit düşmanlar ve yakınlık kontrolleri için kullanışlıdır. Üç boyutta aynı mantık kürelere uygulanır; yalnızca $z$ farkının karesi eklenir.</p>

<h2 id="sat-dönen-nesnelerin-dedektifi">SAT: Dönen Nesnelerin Dedektifi</h2>

<p><strong>Separating Axis Theorem</strong>, iki dışbükey çokgenin çarpışmadığını göstermek için onları ayıran bir eksen arar. İki boyutta her iki çokgenin kenarlarına dik yönler aday eksenlerdir. Köşeleri bu yönlere izdüşürerek minimum ve maksimum değerlerden aralıklar oluşturursunuz.</p>

<p>İzdüşümün temel işlemi noktasal çarpımdır: $p = v \cdot a$. Herhangi bir eksende aralıklar ayrılıyorsa çarpışma yoktur. Bütün aday eksenlerde örtüşme varsa çokgenler kesişir; temasın dahil edilmesi yine karşılaştırma seçiminize bağlıdır.</p>

<p>SAT, dönen kutularda AABB’den daha hassastır. Ancak içbükey şekillere doğrudan uygulanmaz; önce dışbükey parçalara ayırmak gerekir. Ayrıca sıfır uzunluklu kenarlar gibi bozuk geometrileri temizlemelisiniz.</p>

<h2 id="asıl-kazanç-gereksiz-testleri-eleme">Asıl Kazanç: Gereksiz Testleri Eleme</h2>

<p>Pratik sistemler iki aşama kullanır. <strong>Broad phase</strong>, çarpışma ihtimali bulunan çiftleri seçer; <strong>narrow phase</strong>, bu adaylara kesin geometrik test uygular. AABB ilk aşamada kaba sınır, ikinci aşamada ise kutu biçimli nesnenin gerçek çarpışma şekli olabilir.</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Uygun senaryo</th>
      <th>Dikkat edilmesi gereken</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Uniform grid</td>
      <td>Benzer boyutlu nesneler</td>
      <td>Hücre boyutu seçimi</td>
    </tr>
    <tr>
      <td>Quadtree</td>
      <td>Bölgesel yoğunluğu değişen 2B dünya</td>
      <td>Güncelleme maliyeti</td>
    </tr>
    <tr>
      <td>Sweep and prune</td>
      <td>Hareketi görece tutarlı sahneler</td>
      <td>Yoğun örtüşen aralıklar</td>
    </tr>
  </tbody>
</table>

<p>Grid kullanırken nesneyi kapladığı bütün hücrelere ekleyin; yalnızca merkez hücresi yeterli değildir. Birden fazla hücrede bulunan çiftleri tekilleştirin. Bu yöntemler çoğu sahnede işi azaltır, fakat kötü dağılımlarda yine karesel maliyete yaklaşabilir.</p>

<h2 id="hızlı-mermiler-ve-son-kontroller">Hızlı Mermiler ve Son Kontroller</h2>

<p>Ayrık çarpışma tespiti yalnızca belirli zamanlardaki konumlara bakar. Hızlı bir mermi, iki kare arasında ince bir duvarı tamamen geçebilir: buna <strong>tünelleme</strong> denir. Sürekli çarpışma tespiti, hareket boyunca ilk temas zamanını araştırır; swept testler bunun için kullanılır.</p>

<p>Son olarak temas kurallarını tutarlı belirleyin, kayan nokta toleranslarını dünya ölçeğine göre seçin ve çarpışma şekillerini ekranda çizdirin. Görünmez trafik polisini denetlemenin en iyi yolu, ona görünür bir üniforma giydirmektir!</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="oyun geliştirme" /><category term="çarpışma tespiti" /><category term="algoritmalar" /><category term="python" /><category term="geometri" /><category term="performans" /><summary type="html"><![CDATA[Karakteriniz duvardan geçiyor, mermiler hedefi delmeden kayboluyor veya kutular birbirinin içine yerleşiyorsa, oyun dünyanızın trafik polisi biraz uyukluyor olabilir. Çarpışma tespiti, nesnelerin geometrik olarak temas edip etmediğini belirler. İşin püf noktası yalnızca doğru cevabı bulmak değil, bunu her karede binlerce nesne için yeterince hızlı yapabilmektir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/carpisma-tespiti-oyun-43.png" /><media:content medium="image" url="https://program.sonsuz.us/img/carpisma-tespiti-oyun-43.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">DICOM: MR ve Tomografi Görüntülerinin Dijital Anatomisi</title><link href="https://program.sonsuz.us/posts/dicom-mr-ve-tomografi-goruntulerinin-dijital-anatomisi/" rel="alternate" type="text/html" title="DICOM: MR ve Tomografi Görüntülerinin Dijital Anatomisi" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/dicom-mr-ve-tomografi-goruntulerinin-dijital-anatomisi</id><content type="html" xml:base="https://program.sonsuz.us/posts/dicom-mr-ve-tomografi-goruntulerinin-dijital-anatomisi/"><![CDATA[<p>Bir tomografi görüntüsünü sıradan bir fotoğraf gibi saklasaydık ne kaybederdik? Pikselin hastanın neresine ait olduğunu, hangi cihazla üretildiğini ve parlaklığının fiziksel anlamını! DICOM, bu bilgileri görüntüyle birlikte taşıyan ortak dildir. Onu, yalnızca fotoğrafı değil, fotoğrafın teknik pasaportunu da saklayan bir zarf gibi düşünebilirsiniz.</p>

<p>``</p>

<h2 id="dicom-yalnızca-bir-dosya-uzantısı-değildir">DICOM yalnızca bir dosya uzantısı değildir</h2>

<p><strong>DICOM</strong>, “Digital Imaging and Communications in Medicine” ifadesinin kısaltmasıdır. Tıbbi görüntülerin saklanmasını, tanımlanmasını ve sistemler arasında aktarılmasını standartlaştırır. Dosyaların <code class="language-plaintext highlighter-rouge">.dcm</code> uzantısı taşıması yaygındır; ancak uzantı tek başına güvenilir bir format göstergesi değildir.</p>

<p>Bir DICOM nesnesi, görüntü verisiyle birlikte <strong>veri elemanları</strong> içerir. Her elemanın bir etiketi, veri türü ve değeri bulunur. Örneğin <code class="language-plaintext highlighter-rouge">(0010,0010)</code> hasta adını, <code class="language-plaintext highlighter-rouge">(0028,0030)</code> piksel aralığını belirtir. Böylece yazılım, sayıları rastgele yorumlamak yerine standart bir sözlüğe başvurur.</p>

<p>Organizasyon genellikle <strong>hasta → çalışma → seri → nesne</strong> şeklindedir. Bir MR incelemesindeki T1 ve T2 çekimleri farklı seriler olabilir. Üstelik bir nesne her zaman tek kesit değildir: çok kareli DICOM nesneleri birden fazla görüntü barındırabilir.</p>

<table>
  <thead>
    <tr>
      <th>Özellik</th>
      <th>DICOM</th>
      <th>Sıradan PNG/JPEG</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Tıbbi metadata</td>
      <td>Standart etiketlerle taşınır</td>
      <td>Yerleşik DICOM yapısı yoktur</td>
    </tr>
    <tr>
      <td>Fiziksel geometri</td>
      <td>Konum, yön ve aralık bilgileri bulunabilir</td>
      <td>Genellikle yalnızca görüntü boyutu vardır</td>
    </tr>
    <tr>
      <td>Piksel anlamı</td>
      <td>Ölçekleme bilgileriyle yorumlanabilir</td>
      <td>Çoğunlukla gösterim değeridir</td>
    </tr>
    <tr>
      <td>Klinik aktarım</td>
      <td>Standart iletişim mekanizmaları vardır</td>
      <td>Genel dosya aktarımı kullanılır</td>
    </tr>
  </tbody>
</table>

<h2 id="piksel-değerleri-neden-doğrudan-görüntü-değildir">Piksel değerleri neden doğrudan görüntü değildir?</h2>

<p>Bilgisayarlı tomografide saklanan piksel değeri çoğu zaman doğrudan Hounsfield birimi değildir. Yaygın dönüşüm şöyledir:</p>

\[H = mP + b\]

<p>Burada $P$ saklanan değer, $m$ <code class="language-plaintext highlighter-rouge">RescaleSlope</code>, $b$ ise <code class="language-plaintext highlighter-rouge">RescaleIntercept</code> değeridir. Örneğin $P=1024$, $m=1$ ve $b=-1024$ için sonuç $0$ HU olur; bu, yaklaşık olarak suyun değeridir. Uygulanacak dönüşüm yine nesnenin etiketlerinden doğrulanmalıdır.</p>

<p>MR görüntülerinde ise tüm çekimler için geçerli bir HU ölçeği bulunmaz. Sinyal; sekansa, cihaz ayarlarına ve rekonstrüksiyona bağlıdır. Dolayısıyla BT için yazılan normalizasyonu MR’a kopyalamak, kahve makinesine çay tarifi yüklemek gibidir: çalışabilir, ama beklediğiniz sonucu vermeyebilir.</p>

<p><strong>Pencereleme</strong>, geniş yoğunluk aralığının seçilen bölümünü ekranda görünür yapar. Pencere merkezi $c$, genişliği $w$ ile gösterilir. Kemik ve yumuşak doku pencereleri aynı veriyi farklı aralıklarla sunar; alttaki ölçümler değişmez.</p>

<h2 id="python-ile-kontrollü-bir-ilk-okuma">Python ile kontrollü bir ilk okuma</h2>

<p>Aşağıdaki örnek için <code class="language-plaintext highlighter-rouge">pip install pydicom numpy</code> yeterlidir. Kod, tek kareli bir BT dosyasını okuyup modalite dönüşümünü uygular ve seçilen pencereyi 8 bitlik gösterim dizisine dönüştürür:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">numpy</span> <span class="k">as</span> <span class="n">np</span>
<span class="kn">import</span> <span class="n">pydicom</span>
<span class="kn">from</span> <span class="n">pydicom.pixels</span> <span class="kn">import</span> <span class="n">apply_modality_lut</span>

<span class="n">ds</span> <span class="o">=</span> <span class="n">pydicom</span><span class="p">.</span><span class="nf">dcmread</span><span class="p">(</span><span class="sh">"</span><span class="s">ornek_bt.dcm</span><span class="sh">"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ds</span><span class="p">.</span><span class="n">Modality</span> <span class="o">!=</span> <span class="sh">"</span><span class="s">CT</span><span class="sh">"</span><span class="p">:</span>
    <span class="k">raise</span> <span class="nc">ValueError</span><span class="p">(</span><span class="sh">"</span><span class="s">Bu örnek yalnızca BT içindir.</span><span class="sh">"</span><span class="p">)</span>

<span class="n">pixels</span> <span class="o">=</span> <span class="n">ds</span><span class="p">.</span><span class="n">pixel_array</span>
<span class="k">if</span> <span class="n">pixels</span><span class="p">.</span><span class="n">ndim</span> <span class="o">!=</span> <span class="mi">2</span><span class="p">:</span>
    <span class="k">raise</span> <span class="nc">ValueError</span><span class="p">(</span><span class="sh">"</span><span class="s">Tek kareli görüntü bekleniyor.</span><span class="sh">"</span><span class="p">)</span>

<span class="n">hu</span> <span class="o">=</span> <span class="nf">apply_modality_lut</span><span class="p">(</span><span class="n">pixels</span><span class="p">,</span> <span class="n">ds</span><span class="p">).</span><span class="nf">astype</span><span class="p">(</span><span class="n">np</span><span class="p">.</span><span class="n">float32</span><span class="p">)</span>
<span class="n">center</span><span class="p">,</span> <span class="n">width</span> <span class="o">=</span> <span class="mf">40.0</span><span class="p">,</span> <span class="mf">400.0</span>
<span class="n">scaled</span> <span class="o">=</span> <span class="p">(</span><span class="n">hu</span> <span class="o">-</span> <span class="p">(</span><span class="n">center</span> <span class="o">-</span> <span class="mf">0.5</span><span class="p">))</span> <span class="o">/</span> <span class="p">(</span><span class="n">width</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">+</span> <span class="mf">0.5</span>
<span class="n">view</span> <span class="o">=</span> <span class="p">(</span><span class="n">np</span><span class="p">.</span><span class="nf">clip</span><span class="p">(</span><span class="n">scaled</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span> <span class="o">*</span> <span class="mi">255</span><span class="p">).</span><span class="nf">astype</span><span class="p">(</span><span class="n">np</span><span class="p">.</span><span class="n">uint8</span><span class="p">)</span>
<span class="nf">print</span><span class="p">(</span><span class="n">view</span><span class="p">.</span><span class="n">shape</span><span class="p">,</span> <span class="n">view</span><span class="p">.</span><span class="n">dtype</span><span class="p">)</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">apply_modality_lut</code>, elle katsayı çarpmaktan daha güvenli biçimde ilgili dönüşüm etiketlerini kullanır. Pencere hesabı, $w&gt;1$ için DICOM’un <code class="language-plaintext highlighter-rouge">LINEAR</code> yaklaşımını izler. <code class="language-plaintext highlighter-rouge">view</code> gösterim içindir; nicel analizde pencereleme öncesindeki değerleri korumak gerekir. Sıkıştırılmış dosyalarda ayrıca uygun bir piksel çözücü gerekebilir.</p>

<h2 id="kesitleri-birleştirirken-geometriyi-unutmayın">Kesitleri birleştirirken geometriyi unutmayın</h2>

<p>Üç boyutlu hacim oluştururken dosya adına veya yalnızca <code class="language-plaintext highlighter-rouge">InstanceNumber</code> değerine göre sıralamak güvenilir değildir. <code class="language-plaintext highlighter-rouge">ImagePositionPatient</code> ve <code class="language-plaintext highlighter-rouge">ImageOrientationPatient</code>, kesitlerin hasta koordinatlarındaki konumunu ve yönünü belirlemeye yardımcı olur. Konumları kesit normaline izdüşürerek sıralamak daha sağlamdır.</p>

<p>Piksel aralığı ve gerçek kesit konumları da önemlidir. Yanlış eksen sırası, ters yön veya göz ardı edilen düzensiz aralıklar; hacim ölçümünü ve model eğitimini bozabilir. Modeliniz anatomiyi öğrenmek yerine veri hazırlama hatalarını ezberlemesin!</p>

<h2 id="saklama-paylaşma-ve-mahremiyet">Saklama, paylaşma ve mahremiyet</h2>

<p>Hastanelerde görüntüler çoğunlukla <strong>PACS</strong> sistemlerinde yönetilir. DICOM ağ hizmetleri ve DICOMweb, görüntülerin gönderilmesini, sorgulanmasını ve alınmasını sağlar. Ancak standarda uygun olmak, otomatik olarak güvenli olmak değildir; şifreli bağlantı, erişim kontrolü ve denetim kayıtları ayrıca tasarlanmalıdır.</p>

<p>Araştırma öncesinde yalnızca hasta adını silmek yeterli olmaz. Özel etiketler, tarihler, kimlikler ve görüntüye gömülü yazılar da kişisel bilgi taşıyabilir. Kimliksizleştirme, ilişkileri koruyan tutarlı UID eşlemeleriyle ve uygun gizlilik profilleriyle yapılmalıdır.</p>

<p>Kısacası DICOM’u doğru işlemek, piksel okumaktan fazlasıdır: <strong>anlamı, geometriyi ve mahremiyeti birlikte korumaktır.</strong> Klinik kullanımda ayrıca doğrulanmış araçlar ve uzman değerlendirmesi gerekir.</p>

<p><img src="/img/dicom-mr-ve-47.svg" alt="dicom-mr-ve-47" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="dicom" /><category term="tıbbi görüntüleme" /><category term="python" /><category term="pydicom" /><category term="manyetik rezonans" /><category term="bilgisayarlı tomografi" /><summary type="html"><![CDATA[Bir tomografi görüntüsünü sıradan bir fotoğraf gibi saklasaydık ne kaybederdik? Pikselin hastanın neresine ait olduğunu, hangi cihazla üretildiğini ve parlaklığının fiziksel anlamını! DICOM, bu bilgileri görüntüyle birlikte taşıyan ortak dildir. Onu, yalnızca fotoğrafı değil, fotoğrafın teknik pasaportunu da saklayan bir zarf gibi düşünebilirsiniz.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/dicom-mr-ve-47.png" /><media:content medium="image" url="https://program.sonsuz.us/img/dicom-mr-ve-47.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Dijital Kültürel Mirası Geleceğe Taşımak: Format Eskimesine Karşı Arşiv Stratejileri</title><link href="https://program.sonsuz.us/posts/dijital-kulturel-mirasi-gelecege-tasimak-format-eskimesine-karsi-arsiv-stratejileri/" rel="alternate" type="text/html" title="Dijital Kültürel Mirası Geleceğe Taşımak: Format Eskimesine Karşı Arşiv Stratejileri" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/dijital-kulturel-mirasi-gelecege-tasimak-format-eskimesine-karsi-arsiv-stratejileri</id><content type="html" xml:base="https://program.sonsuz.us/posts/dijital-kulturel-mirasi-gelecege-tasimak-format-eskimesine-karsi-arsiv-stratejileri/"><![CDATA[<p>Bir müzenin fotoğrafları, eski bir bilgisayar oyunu veya araştırmacının ses kayıtları… Hepsi dijital olabilir; fakat hiçbiri kendiliğinden ölümsüz değildir. Dosyanın diskte bulunması, gelecekte açılabileceği anlamına gelmez. Dijital arşivcilik, veriyi yalnızca saklamak değil, onu anlayacak geleceğe de hazırlamaktır. Kısacası mesele, dosyaya bir zaman makinesi bileti almaktır!</p>

<p><img src="/img/dijital-kulturel-mirasi-44.svg" alt="dijital-kulturel-mirasi-44" /></p>

<p>``</p>

<h2 id="dosya-yaşıyor-peki-anlamı">Dosya yaşıyor, peki anlamı?</h2>

<p>Uzun vadeli korumanın üç katmanı vardır: bitlerin bütünlüğü, içeriğin okunabilirliği ve bağlamın korunması. Bir belge değişmeden durabilir; ancak onu açan uygulama kaybolmuşsa okunabilirlik ortadan kalkar. Üstelik belgenin üreticisi, tarihi ve kullanım hakları bilinmiyorsa kültürel değeri de eksik aktarılır.</p>

<p>OAIS referans modeli bu süreci kavramsallaştırır: arşive teslim edilen paket, koruma bilgileriyle zenginleştirilmiş arşiv paketi ve kullanıcıya sunulan dağıtım paketi birbirinden ayrılır. OAIS hazır bir yazılım değil, sorumlulukları ve bilgi akışını tanımlayan bir çerçevedir.</p>

<p>Format eskimesi yalnızca dosya uzantısıyla ilgili değildir. Kodekler, yazı tipleri, eklentiler ve işletim sistemi bağımlılıkları da kaybolabilir. Bir video kapsayıcısının tanınması, içindeki görüntünün çözülebileceğini garanti etmez.</p>

<h2 id="göç-mü-emülasyon-mu">Göç mü, emülasyon mu?</h2>

<p>İki temel yaklaşım, içeriği yeni biçime taşımak ve eski çalışma ortamını yeniden oluşturmaktır. Bunlar rakip değil, tamamlayıcı araçlardır.</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Ne korunur?</th>
      <th>Güçlü tarafı</th>
      <th>Temel risk</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Format göçü</td>
      <td>İçerik yeni formata aktarılır</td>
      <td>Güncel araçlarla erişim</td>
      <td>Özellik veya görünüm kaybı</td>
    </tr>
    <tr>
      <td>Emülasyon</td>
      <td>Eski çalışma ortamı taklit edilir</td>
      <td>Etkileşimli deneyim</td>
      <td>Ortam ve lisans bağımlılığı</td>
    </tr>
    <tr>
      <td>Bit düzeyinde koruma</td>
      <td>Özgün dosyanın bitleri</td>
      <td>Bütünlük denetimi</td>
      <td>Okunabilirliği garanti etmez</td>
    </tr>
  </tbody>
</table>

<p>Metin belgelerinde uygun PDF/A profilleri, görüntülerde TIFF, seslerde WAV veya FLAC değerlendirilebilir. Ancak hiçbir format sihirli ölümsüzlük iksiri değildir. Seçim; açıklık, araç desteği, doğrulanabilirlik ve koleksiyonun ihtiyaçlarına dayanmalıdır. Dönüştürülen dosyaları doğrulayın; sayfa sayısı, renkler, metin katmanı ve ses süresi gibi önemli özellikleri karşılaştırın. Özgün dosyayı da mutlaka koruyun.</p>

<h2 id="depolama-tek-kopya-tek-macera">Depolama: Tek kopya, tek macera</h2>

<p>3-2-1 yaklaşımı iyi bir başlangıçtır: üç kopya, iki farklı ortam türü ve bir coğrafi olarak ayrı kopya. Fidye yazılımlarına karşı çevrimdışı veya değiştirilemez kopyalar da düşünülmelidir. Ancak yedekleme, tek başına dijital koruma değildir.</p>

<p>Bağımsız kopyaların belirli bir dönemde kaybolma olasılığı $p$ ise, $n$ kopyanın tamamının kaybolması teorik olarak:</p>

\[P_{\text{tam kayıp}} = p^n\]

<p>Bu ifade yalnızca kayıplar bağımsızsa geçerlidir. Aynı binadaki sunucular yangında birlikte kaybolabilir; aynı yönetici hesabına bağlı bulut kopyaları birlikte silinebilir. Kopya sayısı kadar hata alanlarını ayırmak da önemlidir.</p>

<h2 id="python-ile-bütünlük-kontrolü">Python ile bütünlük kontrolü</h2>

<p>Aşağıdaki örnek, Python 3.9 ve üzerinde dosyaların SHA-256 özetlerini kaydeder; sonraki çalıştırmalarda değişen, eksilen veya eklenen dosyaları bildirir. Büyük dosyalar belleğe bütünüyle alınmaz.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">hashlib</span>
<span class="kn">import</span> <span class="n">json</span>
<span class="kn">import</span> <span class="n">sys</span>
<span class="kn">from</span> <span class="n">pathlib</span> <span class="kn">import</span> <span class="n">Path</span>


<span class="k">def</span> <span class="nf">digest</span><span class="p">(</span><span class="n">path</span><span class="p">):</span>
    <span class="n">h</span> <span class="o">=</span> <span class="n">hashlib</span><span class="p">.</span><span class="nf">sha256</span><span class="p">()</span>
    <span class="k">with</span> <span class="n">path</span><span class="p">.</span><span class="nf">open</span><span class="p">(</span><span class="sh">"</span><span class="s">rb</span><span class="sh">"</span><span class="p">)</span> <span class="k">as</span> <span class="n">stream</span><span class="p">:</span>
        <span class="k">for</span> <span class="n">chunk</span> <span class="ow">in</span> <span class="nf">iter</span><span class="p">(</span><span class="k">lambda</span><span class="p">:</span> <span class="n">stream</span><span class="p">.</span><span class="nf">read</span><span class="p">(</span><span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">),</span> <span class="sa">b</span><span class="sh">""</span><span class="p">):</span>
            <span class="n">h</span><span class="p">.</span><span class="nf">update</span><span class="p">(</span><span class="n">chunk</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">h</span><span class="p">.</span><span class="nf">hexdigest</span><span class="p">()</span>


<span class="n">root</span> <span class="o">=</span> <span class="nc">Path</span><span class="p">(</span><span class="n">sys</span><span class="p">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">1</span><span class="p">]).</span><span class="nf">resolve</span><span class="p">()</span>
<span class="n">manifest</span> <span class="o">=</span> <span class="nc">Path</span><span class="p">(</span><span class="n">sys</span><span class="p">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">2</span><span class="p">]).</span><span class="nf">resolve</span><span class="p">()</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">root</span><span class="p">.</span><span class="nf">is_dir</span><span class="p">():</span>
    <span class="k">raise</span> <span class="nc">ValueError</span><span class="p">(</span><span class="sh">"</span><span class="s">Koleksiyon klasörü bulunamadı.</span><span class="sh">"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">manifest</span><span class="p">.</span><span class="nf">is_relative_to</span><span class="p">(</span><span class="n">root</span><span class="p">):</span>
    <span class="k">raise</span> <span class="nc">ValueError</span><span class="p">(</span><span class="sh">"</span><span class="s">Manifesti koleksiyon dışında saklayın.</span><span class="sh">"</span><span class="p">)</span>

<span class="n">current</span> <span class="o">=</span> <span class="p">{</span>
    <span class="n">p</span><span class="p">.</span><span class="nf">relative_to</span><span class="p">(</span><span class="n">root</span><span class="p">).</span><span class="nf">as_posix</span><span class="p">():</span> <span class="nf">digest</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
    <span class="k">for</span> <span class="n">p</span> <span class="ow">in</span> <span class="nf">sorted</span><span class="p">(</span><span class="n">root</span><span class="p">.</span><span class="nf">rglob</span><span class="p">(</span><span class="sh">"</span><span class="s">*</span><span class="sh">"</span><span class="p">))</span>
    <span class="k">if</span> <span class="n">p</span><span class="p">.</span><span class="nf">is_file</span><span class="p">()</span> <span class="ow">and</span> <span class="ow">not</span> <span class="n">p</span><span class="p">.</span><span class="nf">is_symlink</span><span class="p">()</span>
<span class="p">}</span>

<span class="k">if</span> <span class="n">sys</span><span class="p">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="o">==</span> <span class="sh">"</span><span class="s">init</span><span class="sh">"</span><span class="p">:</span>
    <span class="k">with</span> <span class="n">manifest</span><span class="p">.</span><span class="nf">open</span><span class="p">(</span><span class="sh">"</span><span class="s">x</span><span class="sh">"</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="sh">"</span><span class="s">utf-8</span><span class="sh">"</span><span class="p">)</span> <span class="k">as</span> <span class="n">stream</span><span class="p">:</span>
        <span class="n">json</span><span class="p">.</span><span class="nf">dump</span><span class="p">(</span><span class="n">current</span><span class="p">,</span> <span class="n">stream</span><span class="p">,</span> <span class="n">ensure_ascii</span><span class="o">=</span><span class="bp">False</span><span class="p">,</span> <span class="n">indent</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
    <span class="n">expected</span> <span class="o">=</span> <span class="n">json</span><span class="p">.</span><span class="nf">loads</span><span class="p">(</span><span class="n">manifest</span><span class="p">.</span><span class="nf">read_text</span><span class="p">(</span><span class="n">encoding</span><span class="o">=</span><span class="sh">"</span><span class="s">utf-8</span><span class="sh">"</span><span class="p">))</span>
    <span class="n">changes</span> <span class="o">=</span> <span class="p">[</span>
        <span class="n">name</span> <span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="nf">sorted</span><span class="p">(</span><span class="n">expected</span><span class="p">.</span><span class="nf">keys</span><span class="p">()</span> <span class="o">|</span> <span class="n">current</span><span class="p">.</span><span class="nf">keys</span><span class="p">())</span>
        <span class="k">if</span> <span class="n">expected</span><span class="p">.</span><span class="nf">get</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="o">!=</span> <span class="n">current</span><span class="p">.</span><span class="nf">get</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
    <span class="p">]</span>
    <span class="nf">print</span><span class="p">(</span><span class="sh">"</span><span class="s">Değişen, eksik veya yeni dosyalar:</span><span class="sh">"</span><span class="p">,</span> <span class="n">changes</span><span class="p">)</span>
    <span class="n">sys</span><span class="p">.</span><span class="nf">exit</span><span class="p">(</span><span class="nf">bool</span><span class="p">(</span><span class="n">changes</span><span class="p">))</span>
</code></pre></div></div>

<p>İlk kayıt için <code class="language-plaintext highlighter-rouge">python kontrol.py koleksiyon manifest.json init</code>, denetim için son argümanı <code class="language-plaintext highlighter-rouge">check</code> yapın. Manifestin yanlışlıkla üzerine yazılması engellenir. Sembolik bağlantılar kapsam dışıdır. Özetler özgünlüğü tek başına kanıtlamaz; güvenilir manifesti ayrı, korumalı bir yerde tutun. Değişiklik saptandığında inceleme yapmadan başlangıç kaydını yenilemeyin.</p>

<h2 id="arşivi-yaşayan-bir-sisteme-dönüştürün">Arşivi yaşayan bir sisteme dönüştürün</h2>

<p>PREMIS gibi koruma metaverisiyle dönüşümleri, kullanılan araç sürümlerini, kontrol sonuçlarını ve sorumluları kaydedin. Dosyanın özgünüyle türevi arasındaki ilişkiyi açık tutun. Şifreleme kullanıyorsanız anahtarların korunmasını ve erişim yetkilerinin devrini de planlayın.</p>

<p>Düzenli bütünlük taramaları, geri yükleme tatbikatları ve format risk değerlendirmeleri için takvim oluşturun. Depolama ortamlarını gerektiğinde yenileyin; telif ve kişisel veri koşullarını erişim politikalarına yansıtın. Bütçe ve görev sahipleri belirlenmeden hiçbir teknik çözüm sürdürülebilir olmaz. Başarı, gelecekteki kullanıcının yalnızca dosyayı bulması değil, içeriği doğru biçimde anlayabilmesidir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="dijital arşivleme" /><category term="kültürel miras" /><category term="veri koruma" /><category term="format eskimesi" /><category term="dijital koruma" /><category term="python" /><summary type="html"><![CDATA[Bir müzenin fotoğrafları, eski bir bilgisayar oyunu veya araştırmacının ses kayıtları… Hepsi dijital olabilir; fakat hiçbiri kendiliğinden ölümsüz değildir. Dosyanın diskte bulunması, gelecekte açılabileceği anlamına gelmez. Dijital arşivcilik, veriyi yalnızca saklamak değil, onu anlayacak geleceğe de hazırlamaktır. Kısacası mesele, dosyaya bir zaman makinesi bileti almaktır!]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/dijital-kulturel-mirasi-44.png" /><media:content medium="image" url="https://program.sonsuz.us/img/dijital-kulturel-mirasi-44.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">GPS Olmadan Rotayı Korumak: Dronların Otonom Uçuş Algoritmaları</title><link href="https://program.sonsuz.us/posts/gps-olmadan-rotayi-korumak-dronlarin-otonom-ucus-algoritmalari/" rel="alternate" type="text/html" title="GPS Olmadan Rotayı Korumak: Dronların Otonom Uçuş Algoritmaları" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/gps-olmadan-rotayi-korumak-dronlarin-otonom-ucus-algoritmalari</id><content type="html" xml:base="https://program.sonsuz.us/posts/gps-olmadan-rotayi-korumak-dronlarin-otonom-ucus-algoritmalari/"><![CDATA[<p>Bir dronun GPS bağlantısı kesildiğinde gökyüzünde şaşkın şaşkın dolaşması gerekmez. Kameralar, hareket sensörleri ve doğru algoritmalar sayesinde uçuşunu sürdürebilir. Ancak mesele yalnızca engelleri görmek değildir: Araç, nerede olduğunu kestirmeli, hedefinden sapmasını hesaplamalı ve motorlarına uygun komutlar üretmelidir. Gelin bu uçan robotun navigasyon defterini açalım.
``</p>

<h2 id="önce-temel-ayrım-kestirim-ve-kontrol">Önce temel ayrım: Kestirim ve kontrol</h2>

<p>Otonom uçuşta iki farklı soru vardır: <strong>“Neredeyim?”</strong> ve <strong>“Nereye, nasıl gitmeliyim?”</strong> İlkini durum kestirimi, ikincisini planlama ve kontrol algoritmaları cevaplar. Bu görevleri karıştırmak, gözlüğün direksiyon çevirmesini beklemek gibidir.</p>

<p>GPS olmadan genellikle kalkış noktasına bağlı yerel bir koordinat sistemi kullanılır. Dron bu sistemde konumunu, hızını ve yönelimini izler. Fakat yerel rotayı korumak, dünya üzerindeki mutlak konumu kusursuz bilmek anlamına gelmez. Harita eşleştirmesi veya bilinen işaretler gibi dış referanslar yoksa hata zamanla birikir.</p>

<p>Kestirilen durum; konum $p$, hız $v$, yönelim $R$ ve sensör sapmalarını içerebilir:</p>

\[x=[p,v,R,b_a,b_g]\]

<h2 id="imu-kamera-ve-sensör-füzyonu">IMU, kamera ve sensör füzyonu</h2>

<p>IMU, ivmeölçer ve jiroskoptan oluşur. Jiroskop açısal hızı, ivmeölçer ise yerçekiminden ayrıştırılması gereken özgül kuvveti ölçer. Dünya koordinatlarındaki ivme yaklaşık şöyle hesaplanır:</p>

\[a_w=R(a_m-b_a)+g_w\]

<p>Burada $a_m$ ölçüm, $b_a$ ivmeölçer sapması, $g_w$ yerçekimi vektörüdür. İvmenin zaman boyunca entegrasyonu hız ve konum verir. Ne var ki küçük sapmalar büyür: Basitleştirilmiş sabit sapma modelinde konum hatası yaklaşık $b_a t^2/2$ ile artar. Yani IMU hızlıdır, fakat tek başına uzun süre güvenilir bir konum kaynağı değildir.</p>

<p>Kamera bu açığı kapatmaya yardım eder. <strong>Görsel ataletsel odometri</strong>, görüntülerdeki özellik noktalarının hareketini IMU verileriyle birleştirir. SLAM ise konum kestirirken çevrenin haritasını da oluşturur.</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Güçlü yanı</th>
      <th>Temel sınırlama</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Yalnız IMU</td>
      <td>Hızlı hareket takibi</td>
      <td>Biriken konum hatası</td>
    </tr>
    <tr>
      <td>Optik akış ve mesafe sensörü</td>
      <td>Zemine göre hız kestirimi</td>
      <td>Doku ve yükseklik ölçümüne bağımlılık</td>
    </tr>
    <tr>
      <td>Görsel ataletsel odometri</td>
      <td>Yerel hareket kestirimi</td>
      <td>Işık, bulanıklık ve kalibrasyon</td>
    </tr>
    <tr>
      <td>SLAM ve harita eşleştirme</td>
      <td>Tekrar görülen yerlerle düzeltme</td>
      <td>İşlem yükü ve yanlış eşleşmeler</td>
    </tr>
  </tbody>
</table>

<p>Genişletilmiş Kalman filtresi gibi yöntemler, hareket modeliyle tahmin üretir ve sensör ölçümleriyle tahmini düzeltir. Ölçümlerin belirsizliği önemlidir: Bulanık kameraya daha az güvenmek gerekir. Tek kameralı sistemlerde ölçek de kritik olduğundan, yeterli hareket uyarımı ve doğru IMU kalibrasyonu gerekir.</p>

<h2 id="rotayı-korumak-hata-üzerinden-kontrol">Rotayı korumak: Hata üzerinden kontrol</h2>

<p>Konum tahmini hazırsa kontrolcü hedef ile mevcut konum arasındaki farkı hesaplar. Yaygın mimaride dış döngü konumdan hız veya ivme hedefi üretir; iç döngüler yönelim ve açısal hızı düzenler. Motorlar bu zincirin son halkasıdır.</p>

<p>Sabit bir yatay hedef için basit bir PD kontrolcü:</p>

\[a_{komut}=K_p(p_{hedef}-p)-K_dv\]

<p>Konum terimi hedefe çeker; hız terimi hareketi sönümleyerek hedef çevresindeki salınımları azaltır. Aşağıdaki örnek, yerel koordinatlardaki komutu sınırlar ve gövde eksenlerine dönüştürür:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">numpy</span> <span class="k">as</span> <span class="n">np</span>


<span class="k">def</span> <span class="nf">yatay_komut</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="n">hedef</span><span class="p">,</span> <span class="n">yaw</span><span class="p">,</span>
                <span class="n">kp</span><span class="o">=</span><span class="mf">0.8</span><span class="p">,</span> <span class="n">kd</span><span class="o">=</span><span class="mf">1.2</span><span class="p">,</span> <span class="n">a_max</span><span class="o">=</span><span class="mf">2.0</span><span class="p">):</span>
    <span class="n">p</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="n">hedef</span> <span class="o">=</span> <span class="p">(</span>
        <span class="n">np</span><span class="p">.</span><span class="nf">asarray</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="nb">float</span><span class="p">)</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="n">hedef</span><span class="p">)</span>
    <span class="p">)</span>
    <span class="k">if</span> <span class="nf">any</span><span class="p">(</span><span class="n">x</span><span class="p">.</span><span class="n">shape</span> <span class="o">!=</span> <span class="p">(</span><span class="mi">2</span><span class="p">,)</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="n">hedef</span><span class="p">)):</span>
        <span class="k">raise</span> <span class="nc">ValueError</span><span class="p">(</span><span class="sh">"</span><span class="s">İki boyutlu vektörler gerekli.</span><span class="sh">"</span><span class="p">)</span>

    <span class="n">a_dunya</span> <span class="o">=</span> <span class="n">kp</span> <span class="o">*</span> <span class="p">(</span><span class="n">hedef</span> <span class="o">-</span> <span class="n">p</span><span class="p">)</span> <span class="o">-</span> <span class="n">kd</span> <span class="o">*</span> <span class="n">v</span>
    <span class="n">norm</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="n">linalg</span><span class="p">.</span><span class="nf">norm</span><span class="p">(</span><span class="n">a_dunya</span><span class="p">)</span>
    <span class="k">if</span> <span class="n">norm</span> <span class="o">&gt;</span> <span class="n">a_max</span><span class="p">:</span>
        <span class="n">a_dunya</span> <span class="o">*=</span> <span class="n">a_max</span> <span class="o">/</span> <span class="n">norm</span>

    <span class="n">c</span><span class="p">,</span> <span class="n">s</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="nf">cos</span><span class="p">(</span><span class="n">yaw</span><span class="p">),</span> <span class="n">np</span><span class="p">.</span><span class="nf">sin</span><span class="p">(</span><span class="n">yaw</span><span class="p">)</span>
    <span class="n">dunya_govde</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="nf">array</span><span class="p">([[</span><span class="n">c</span><span class="p">,</span> <span class="n">s</span><span class="p">],</span> <span class="p">[</span><span class="o">-</span><span class="n">s</span><span class="p">,</span> <span class="n">c</span><span class="p">]])</span>
    <span class="k">return</span> <span class="n">dunya_govde</span> <span class="o">@</span> <span class="n">a_dunya</span>
</code></pre></div></div>

<p>Konum metre, hız metre/saniye, <code class="language-plaintext highlighter-rouge">yaw</code> radyan cinsindedir. Kod yatay ivme isteği üretir; motor komutu üretmez. Pozitif kazançlar ve ivme sınırı varsayılmıştır. Gerçek uçuşta eksen tanımları, itki dönüşümü ve eğim sınırları ayrıca ele alınmalıdır.</p>

<h2 id="daha-akıllı-kontrol-daha-güvenli-uçuş">Daha akıllı kontrol, daha güvenli uçuş</h2>

<p>PID ailesi düşük hesaplama maliyetiyle pratiktir. Model öngörülü kontrol, yani MPC, gelecekteki hareketi bir modelle tahmin ederek izleme hatasını ve kontrol çabasını birlikte optimize eder. Hız, ivme ve eğim kısıtlarını hesaba katabilir; karşılığında daha fazla hesaplama ister. Engel bilgisi ise ayrıca bir planlayıcıdan veya haritadan gelmelidir.</p>

<p>Başarılı sistem yalnızca iyi hava koşullarını düşünmez. Dokusuz duvarlar, karanlık ve titreşim görsel kestirimi bozabilir. Belirsizlik yükseldiğinde hız azaltılmalı; uygun sensörler varsa kontrollü bekleme veya iniş değerlendirilmelidir. Konum kestirimi kaybolmuşken “olduğun yerde kal” komutu tek başına çözüm değildir.</p>

<p>Sonuç olarak GPS’siz uçuş sihir değil, sürekli düzeltilen tahmin ve geri beslemedir. Önce simülasyonda gecikme, sensör kaybı ve sapma senaryolarını deneyin. Dronun gerçek süper gücü, yalnızca rotasını koruması değil, artık güvenilir biçimde koruyamadığını anlayabilmesidir.</p>

<p><img src="/img/gps-olmadan-rotayi-14.svg" alt="gps-olmadan-rotayi-14" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="iha" /><category term="otonom uçuş" /><category term="sensör füzyonu" /><category term="slam" /><category term="kontrol algoritmaları" /><category term="robotik" /><summary type="html"><![CDATA[Bir dronun GPS bağlantısı kesildiğinde gökyüzünde şaşkın şaşkın dolaşması gerekmez. Kameralar, hareket sensörleri ve doğru algoritmalar sayesinde uçuşunu sürdürebilir. Ancak mesele yalnızca engelleri görmek değildir: Araç, nerede olduğunu kestirmeli, hedefinden sapmasını hesaplamalı ve motorlarına uygun komutlar üretmelidir. Gelin bu uçan robotun navigasyon defterini açalım.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/gps-olmadan-rotayi-14.png" /><media:content medium="image" url="https://program.sonsuz.us/img/gps-olmadan-rotayi-14.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">James Webb’in Veri Mutfağı: Ham Fotonlardan Bilimsel Görüntülere</title><link href="https://program.sonsuz.us/posts/james-webbin-veri-mutfagi-ham-fotonlardan-bilimsel-goruntulere/" rel="alternate" type="text/html" title="James Webb’in Veri Mutfağı: Ham Fotonlardan Bilimsel Görüntülere" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/james-webbin-veri-mutfagi-ham-fotonlardan-bilimsel-goruntulere</id><content type="html" xml:base="https://program.sonsuz.us/posts/james-webbin-veri-mutfagi-ham-fotonlardan-bilimsel-goruntulere/"><![CDATA[<p>James Webb Uzay Teleskobu’nun büyüleyici görüntüleri, uzaydan hazır duvar kâğıdı olarak gelmez. İlk veriler; dedektör izleri, kozmik ışın etkileri ve ölçüm belirsizlikleriyle doludur. Bilimsel veri işleme hattı, bu karmaşayı fiziksel olarak anlamlı ölçümlere dönüştürür. Gelin, kozmik mutfağın tezgâhına yaklaşalım: Burada filtre değil, kalibrasyon pişiyor!</p>

<p>``</p>

<h2 id="önce-teori-dedektör-aslında-ne-ölçer">Önce teori: Dedektör aslında ne ölçer?</h2>

<p>Webb’in dedektörleri, poz boyunca biriken sinyali birden fazla kez okur. Bu okumalar, <strong>rampa</strong> denilen bir zaman dizisi oluşturur. İdeal, doğrusal bölgedeki bir pikseli şöyle düşünebiliriz:</p>

\[D(t)=b+rt+\epsilon(t)\]

<p>Burada $b$ başlangıç seviyesi, $r$ sinyalin birikme hızı, $\epsilon(t)$ ise gürültüdür. Amaç yalnızca son okumaya bakmak değil, geçerli okumaların eğiminden güvenilir bir hız ölçmektir. Doygunluk ve kozmik ışın sıçramaları, bu hesabı sıradan bir doğru uydurmaktan daha zor hâle getirir.</p>

<p>Gürültünün iki önemli bileşeni fotonların istatistiksel değişkenliği ve elektronik okuma gürültüsüdür. Kalibrasyon, bunları sihirli biçimde yok etmez; etkilerini modeller ve belirsizlikleri sonraki aşamalara taşır.</p>

<table>
  <thead>
    <tr>
      <th>Aşama</th>
      <th>Temel girdi</th>
      <th>Tipik görüntüleme çıktısı</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Detector1</td>
      <td>Ham okumalar: <code class="language-plaintext highlighter-rouge">uncal</code></td>
      <td>Sinyal hızı: <code class="language-plaintext highlighter-rouge">rate</code></td>
    </tr>
    <tr>
      <td>Image2</td>
      <td>Hız görüntüsü</td>
      <td>Kalibreli görüntü: <code class="language-plaintext highlighter-rouge">cal</code></td>
    </tr>
    <tr>
      <td>Image3</td>
      <td>İlişkilendirilmiş pozlar</td>
      <td>Birleşik mozaik: <code class="language-plaintext highlighter-rouge">i2d</code></td>
    </tr>
  </tbody>
</table>

<p><img src="/img/james-webbin-veri-63.svg" alt="james-webbin-veri-63" /></p>

<h2 id="1-dedektör-düzeltmeleri-elektroniğin-izlerini-temizlemek">1. Dedektör düzeltmeleri: Elektroniğin izlerini temizlemek</h2>

<p>İlk aşamada veri kalite bayrakları hazırlanır; doygun pikseller belirlenir ve dedektöre uygun düzeltmeler uygulanır. Referans piksel düzeltmesi, doğrusal olmayan tepkinin giderilmesi ve karanlık akım düzeltmesi bunlar arasındadır. MIRI ile yakın kızılötesi dedektörlerinin ihtiyaçları aynı olmadığından, adımlar cihaz ve gözlem moduna göre değişir.</p>

<p>Kozmik ışınlar rampada ani sıçramalar bırakabilir. İşlem hattı bu sıçramaları işaretleyerek geçerli rampa parçalarını değerlendirebilir. Böylece tek bir darbe yüzünden bütün poz çöpe gitmez. Rampa uydurması sonucunda, görüntüleme için genellikle DN/s cinsinden bir hız görüntüsü elde edilir.</p>

<h2 id="2-fiziksel-kalibrasyon-pikselden-gökyüzüne">2. Fiziksel kalibrasyon: Pikselden gökyüzüne</h2>

<p>İkinci aşama, ölçümü gökyüzüyle ilişkilendirir. <strong>WCS</strong>, piksel koordinatlarını göksel koordinatlara dönüştüren modeli taşır; optik bozulmalar da bu modelin parçasıdır. Düz alan düzeltmesi, piksellerin farklı duyarlılıklarını dengeler. Fotometrik kalibrasyon ise sayısal sinyali fiziksel birimlere çevirir; görüntüleme ürünlerinde yaygın birim MJy/sr’dir.</p>

<p>Basitleştirilmiş bir ilişki şöyle yazılabilir:</p>

\[I=C\frac{R-B}{F}\]

<p>$R$ hız ölçümü, $B$ arka plan, $F$ göreli duyarlılık ve $C$ dönüşüm katsayısıdır. Bu denklem kavramsaldır; gerçek hattın bütün adımlarını veya kesin işlem sırasını temsil etmez. Özellikle arka planın nerede çıkarılacağı gözleme bağlıdır.</p>

<h2 id="3-birleştirme-kozmik-yapbozu-tamamlamak">3. Birleştirme: Kozmik yapbozu tamamlamak</h2>

<p>Webb aynı alanı küçük konum kaymalarıyla, yani <strong>dither</strong> uygulayarak gözlemleyebilir. Üçüncü aşamada uygun pozlar hizalanır, gerektiğinde arka plan seviyeleri eşleştirilir, aykırı örnekler belirlenir ve ortak bir koordinat ızgarasına yeniden örneklenir.</p>

<p>Drizzle yaklaşımı, bu birleştirmede örneklemeyi ve kapsama alanını iyileştirebilir. Ancak yeni fiziksel ayrıntılar yaratmaz; yeniden örnekleme komşu pikseller arasında gürültü korelasyonu oluşturabilir. Bu nedenle mozaikteki belirsizlikleri bağımsız piksel varsayımıyla yorumlamak her zaman doğru değildir.</p>

<h2 id="python-ile-hattı-çalıştırmak">Python ile hattı çalıştırmak</h2>

<p>STScI’nin <code class="language-plaintext highlighter-rouge">jwst</code> paketini <code class="language-plaintext highlighter-rouge">pip install jwst</code> ile kurabilirsiniz. Aşağıdaki örnek, iki görüntüleme pozunu işler. Dosya adları temsilidir; son çağrı, oluşan <code class="language-plaintext highlighter-rouge">cal</code> dosyalarını üye olarak tanımlayan geçerli bir <code class="language-plaintext highlighter-rouge">goruntu_asn.json</code> ilişkilendirme dosyası gerektirir.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">os</span>

<span class="n">os</span><span class="p">.</span><span class="n">environ</span><span class="p">.</span><span class="nf">setdefault</span><span class="p">(</span><span class="sh">"</span><span class="s">CRDS_PATH</span><span class="sh">"</span><span class="p">,</span> <span class="n">os</span><span class="p">.</span><span class="n">path</span><span class="p">.</span><span class="nf">abspath</span><span class="p">(</span><span class="sh">"</span><span class="s">crds_cache</span><span class="sh">"</span><span class="p">))</span>
<span class="n">os</span><span class="p">.</span><span class="n">environ</span><span class="p">.</span><span class="nf">setdefault</span><span class="p">(</span><span class="sh">"</span><span class="s">CRDS_SERVER_URL</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">https://jwst-crds.stsci.edu</span><span class="sh">"</span><span class="p">)</span>

<span class="kn">from</span> <span class="n">jwst.pipeline</span> <span class="kn">import</span> <span class="n">Detector1Pipeline</span><span class="p">,</span> <span class="n">Image2Pipeline</span><span class="p">,</span> <span class="n">Image3Pipeline</span>

<span class="n">os</span><span class="p">.</span><span class="nf">makedirs</span><span class="p">(</span><span class="sh">"</span><span class="s">urunler</span><span class="sh">"</span><span class="p">,</span> <span class="n">exist_ok</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>

<span class="k">for</span> <span class="n">raw</span> <span class="ow">in</span> <span class="p">[</span><span class="sh">"</span><span class="s">jw_ornek01_uncal.fits</span><span class="sh">"</span><span class="p">,</span> <span class="sh">"</span><span class="s">jw_ornek02_uncal.fits</span><span class="sh">"</span><span class="p">]:</span>
    <span class="n">root</span> <span class="o">=</span> <span class="n">raw</span><span class="p">.</span><span class="nf">removesuffix</span><span class="p">(</span><span class="sh">"</span><span class="s">_uncal.fits</span><span class="sh">"</span><span class="p">)</span>
    <span class="n">Detector1Pipeline</span><span class="p">.</span><span class="nf">call</span><span class="p">(</span>
        <span class="n">raw</span><span class="p">,</span> <span class="n">save_results</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="n">output_dir</span><span class="o">=</span><span class="sh">"</span><span class="s">urunler</span><span class="sh">"</span>
    <span class="p">)</span>
    <span class="n">Image2Pipeline</span><span class="p">.</span><span class="nf">call</span><span class="p">(</span>
        <span class="sa">f</span><span class="sh">"</span><span class="s">urunler/</span><span class="si">{</span><span class="n">root</span><span class="si">}</span><span class="s">_rate.fits</span><span class="sh">"</span><span class="p">,</span>
        <span class="n">save_results</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="n">output_dir</span><span class="o">=</span><span class="sh">"</span><span class="s">urunler</span><span class="sh">"</span>
    <span class="p">)</span>

<span class="n">Image3Pipeline</span><span class="p">.</span><span class="nf">call</span><span class="p">(</span>
    <span class="sh">"</span><span class="s">goruntu_asn.json</span><span class="sh">"</span><span class="p">,</span> <span class="n">save_results</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="n">output_dir</span><span class="o">=</span><span class="sh">"</span><span class="s">urunler</span><span class="sh">"</span>
<span class="p">)</span>
</code></pre></div></div>

<p>CRDS, gözleme uygun kalibrasyon referanslarını seçer. Tekrarlanabilirlik için paket sürümünü, işlem parametrelerini ve kullanılan <code class="language-plaintext highlighter-rouge">CRDS_CONTEXT</code> değerini kaydedin. Spektroskopide ikinci ve üçüncü aşamalar için <code class="language-plaintext highlighter-rouge">Spec2Pipeline</code> ve <code class="language-plaintext highlighter-rouge">Spec3Pipeline</code> kullanılır; dalga boyu kalibrasyonu ve tayf çıkarımı gibi işlemler devreye girer.</p>

<h2 id="son-kontrol-güzel-görünmek-yetmez">Son kontrol: Güzel görünmek yetmez</h2>

<p>Bilimsel analizden önce çıktıların <code class="language-plaintext highlighter-rouge">SCI</code>, <code class="language-plaintext highlighter-rouge">ERR</code> ve <code class="language-plaintext highlighter-rouge">DQ</code> uzantılarını birlikte inceleyin: Bunlar sırasıyla ölçümü, belirsizliği ve kalite bayraklarını taşır. Hizalama hatalarını, arka plan kalıntılarını ve maskelenmiş bölgeleri kontrol edin. Birleşik ürünlerin kapsama ve ağırlık haritaları da hangi bölgelerin daha güvenilir olduğunu gösterir.</p>

<p>Son olarak, renkli sunum görüntülerindeki kontrast ayarlarını bilimsel kalibrasyonla karıştırmayın. İyi bir Webb görüntüsü yalnızca etkileyici görünmez; birimleri, belirsizlikleri ve işlem geçmişiyle savunulabilir bir ölçüm sunar.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="jwst" /><category term="james-webb" /><category term="astronomi" /><category term="veri-isleme" /><category term="python" /><category term="kalibrasyon" /><summary type="html"><![CDATA[James Webb Uzay Teleskobu’nun büyüleyici görüntüleri, uzaydan hazır duvar kâğıdı olarak gelmez. İlk veriler; dedektör izleri, kozmik ışın etkileri ve ölçüm belirsizlikleriyle doludur. Bilimsel veri işleme hattı, bu karmaşayı fiziksel olarak anlamlı ölçümlere dönüştürür. Gelin, kozmik mutfağın tezgâhına yaklaşalım: Burada filtre değil, kalibrasyon pişiyor!]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/james-webbin-veri-63.png" /><media:content medium="image" url="https://program.sonsuz.us/img/james-webbin-veri-63.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Lineer Programlama ile Üretim Planlama: Az Kaynakla En Fazla Ürün</title><link href="https://program.sonsuz.us/posts/lineer-programlama-ile-uretim-planlama-az-kaynakla-en-fazla-urun/" rel="alternate" type="text/html" title="Lineer Programlama ile Üretim Planlama: Az Kaynakla En Fazla Ürün" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/lineer-programlama-ile-uretim-planlama-az-kaynakla-en-fazla-urun</id><content type="html" xml:base="https://program.sonsuz.us/posts/lineer-programlama-ile-uretim-planlama-az-kaynakla-en-fazla-urun/"><![CDATA[<p><img src="/img/lineer-programlama-ile-13.svg" alt="lineer-programlama-ile-13" /></p>

<p>Bir fabrikanın elinde sınırlı işçilik ve makine süresi varsa, hangi üründen kaç adet üretmesi gerekir? Sezgiler başlangıç için güzeldir; ancak kaynaklar daraldığında matematik daha iyi bir vardiya şefi olabilir. Lineer programlama, üretim kararlarını ölçülebilir bir modele dönüştürerek mümkün olan en yüksek çıktıyı bulmamızı sağlar.</p>

<p>``</p>

<h2 id="üretim-kararlarını-matematiğe-çevirelim">Üretim kararlarını matematiğe çevirelim</h2>

<p>Lineer programlama üç temel parçadan oluşur: karar değişkenleri, amaç fonksiyonu ve kısıtlar. Karar değişkenleri kontrol edebildiğimiz miktarlardır. Amaç fonksiyonu iyileştirmek istediğimiz sonucu tanımlar. Kısıtlar ise bütçe, zaman, kapasite veya talep gibi sınırları temsil eder. Kısacası model, “Ne istiyorum?” ve “Neye izin var?” sorularını birlikte cevaplar.</p>

<p>Buradaki “lineer” sözcüğü önemlidir: Her ek ürünün aynı miktarda kaynak tükettiğini varsayarız. İki ürün üretmek, bir ürünün iki katı kaynağı gerektirir. Sabit kurulum maliyetleri, miktara bağlı indirimler veya üretim hızındaki değişimler bu basit yapıya doğrudan uymaz. Modelin başarısı, varsayımlarının gerçek üretim ortamına uygunluğuna bağlıdır.</p>

<h2 id="i̇ki-ürün-iki-sınırlı-kaynak">İki ürün, iki sınırlı kaynak</h2>

<p>A ve B ürünlerini üreten küçük bir atölye düşünelim. Planlama dönemi boyunca 100 saat işçilik ve 90 saat makine kapasitemiz var. Malzeme ve talebin üretimi sınırlamadığını varsayalım. Ürün başına kaynak tüketimleri şöyle olsun:</p>

<table>
  <thead>
    <tr>
      <th>Kaynak</th>
      <th style="text-align: right">A ürünü</th>
      <th style="text-align: right">B ürünü</th>
      <th style="text-align: right">Kullanılabilir kapasite</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>İşçilik</td>
      <td style="text-align: right">2 saat</td>
      <td style="text-align: right">1 saat</td>
      <td style="text-align: right">100 saat</td>
    </tr>
    <tr>
      <td>Makine</td>
      <td style="text-align: right">1 saat</td>
      <td style="text-align: right">3 saat</td>
      <td style="text-align: right">90 saat</td>
    </tr>
  </tbody>
</table>

<p>A üretimini $x$, B üretimini $y$ ile gösterelim. Hedefimiz toplam ürün adedini artırmak:</p>

\[\max Z=x+y\]

<p>Kaynak sınırları ve negatif üretimin mümkün olmaması şu kısıtları verir:</p>

<p>\(2x+y\le100\)
\(x+3y\le90\)
\(x\ge0,\qquad y\ge0\)</p>

<p>Burada adetleri eşit ağırlıklandırıyoruz. A ve B farklı ekonomik değerler taşıyorsa, maksimum adet ile maksimum kâr aynı hedef değildir. Kâr optimizasyonunda amaç fonksiyonuna ürünlerin birim katkı payları yazılmalıdır. Matematik aynı kalır; yöneldiğimiz hedef değişir.</p>

<h2 id="en-iyi-üretim-karması-nerede">En iyi üretim karması nerede?</h2>

<p>Kısıtların birlikte izin verdiği noktalar, uygun çözüm bölgesini oluşturur. Bu örnekte bölge sınırlıdır ve lineer amaç fonksiyonunun optimumu köşe noktalarından birinde bulunabilir. Dolayısıyla rastgele üretim kombinasyonları denemek yerine geometriden yararlanabiliriz.</p>

<p>İki kaynak sınırının kesişimini hesaplayalım:</p>

\[2x+y=100,\qquad x+3y=90\]

<p>Denklemleri çözdüğümüzde $x=42$ ve $y=16$ elde ederiz. Toplam üretim $Z=58$ adettir. Diğer köşeler olan $(0,0)$, $(50,0)$ ve $(0,30)$ daha düşük çıktı verir.</p>

<table>
  <thead>
    <tr>
      <th>Üretim yaklaşımı</th>
      <th style="text-align: right">A adedi</th>
      <th style="text-align: right">B adedi</th>
      <th style="text-align: right">Toplam</th>
      <th>Durum</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Yalnızca A</td>
      <td style="text-align: right">50</td>
      <td style="text-align: right">0</td>
      <td style="text-align: right">50</td>
      <td>Uygun</td>
    </tr>
    <tr>
      <td>Yalnızca B</td>
      <td style="text-align: right">0</td>
      <td style="text-align: right">30</td>
      <td style="text-align: right">30</td>
      <td>Uygun</td>
    </tr>
    <tr>
      <td>Eşit miktarda üretim</td>
      <td style="text-align: right">20</td>
      <td style="text-align: right">20</td>
      <td style="text-align: right">40</td>
      <td>Uygun</td>
    </tr>
    <tr>
      <td>Optimize edilmiş karma</td>
      <td style="text-align: right">42</td>
      <td style="text-align: right">16</td>
      <td style="text-align: right">58</td>
      <td>Optimal</td>
    </tr>
  </tbody>
</table>

<p>Demek ki tek ürüne yüklenmek yerine kaynak tüketimleri birbirini tamamlayan bir karışım seçmek avantajlı. Matematik, atölyenin menüsüne dengeli bir tabak hazırlıyor!</p>

<h2 id="python-ile-modeli-çözelim">Python ile modeli çözelim</h2>

<p>Önce <code class="language-plaintext highlighter-rouge">pip install scipy numpy</code> komutuyla gerekli paketleri kurabilirsiniz. SciPy içindeki <code class="language-plaintext highlighter-rouge">linprog</code> minimizasyon yaptığı için amaç katsayılarını negatif veririz. Böylece $-(x+y)$ değerini küçültmek, toplam üretimi büyütmekle eşdeğer olur.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">numpy</span> <span class="k">as</span> <span class="n">np</span>
<span class="kn">from</span> <span class="n">scipy.optimize</span> <span class="kn">import</span> <span class="n">linprog</span>

<span class="n">resource_matrix</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="nf">array</span><span class="p">([[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">]])</span>
<span class="n">capacities</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="nf">array</span><span class="p">([</span><span class="mi">100</span><span class="p">,</span> <span class="mi">90</span><span class="p">])</span>

<span class="n">result</span> <span class="o">=</span> <span class="nf">linprog</span><span class="p">(</span>
    <span class="n">c</span><span class="o">=</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">],</span>
    <span class="n">A_ub</span><span class="o">=</span><span class="n">resource_matrix</span><span class="p">,</span>
    <span class="n">b_ub</span><span class="o">=</span><span class="n">capacities</span><span class="p">,</span>
    <span class="n">bounds</span><span class="o">=</span><span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="bp">None</span><span class="p">),</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="bp">None</span><span class="p">)],</span>
    <span class="n">method</span><span class="o">=</span><span class="sh">"</span><span class="s">highs</span><span class="sh">"</span><span class="p">,</span>
<span class="p">)</span>

<span class="k">if</span> <span class="ow">not</span> <span class="n">result</span><span class="p">.</span><span class="n">success</span><span class="p">:</span>
    <span class="k">raise</span> <span class="nc">RuntimeError</span><span class="p">(</span><span class="n">result</span><span class="p">.</span><span class="n">message</span><span class="p">)</span>

<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">result</span><span class="p">.</span><span class="n">x</span>
<span class="n">remaining</span> <span class="o">=</span> <span class="n">capacities</span> <span class="o">-</span> <span class="n">resource_matrix</span> <span class="o">@</span> <span class="n">result</span><span class="p">.</span><span class="n">x</span>
<span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">A: </span><span class="si">{</span><span class="n">x</span><span class="si">:</span><span class="p">.</span><span class="mi">2</span><span class="n">f</span><span class="si">}</span><span class="s">, B: </span><span class="si">{</span><span class="n">y</span><span class="si">:</span><span class="p">.</span><span class="mi">2</span><span class="n">f</span><span class="si">}</span><span class="sh">"</span><span class="p">)</span>
<span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">"</span><span class="s">Toplam üretim: </span><span class="si">{</span><span class="o">-</span><span class="n">result</span><span class="p">.</span><span class="n">fun</span><span class="si">:</span><span class="p">.</span><span class="mi">2</span><span class="n">f</span><span class="si">}</span><span class="sh">"</span><span class="p">)</span>
<span class="nf">print</span><span class="p">(</span><span class="sh">"</span><span class="s">Kalan kaynak saatleri:</span><span class="sh">"</span><span class="p">,</span> <span class="n">remaining</span><span class="p">)</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">A_ub</code> kaynak tüketimlerini, <code class="language-plaintext highlighter-rouge">b_ub</code> kapasiteleri taşır. <code class="language-plaintext highlighter-rouge">bounds</code> negatif üretimi engeller. Son satırlar hem optimum miktarları hem de kullanılmayan kapasiteyi gösterir. Bu örnekte iki kaynak da tamamen kullanılır; sayısal toleranslar nedeniyle sıfıra çok yakın artıklar görülebilir.</p>

<h2 id="sonucu-doğrulayın-varsayımları-unutmayın">Sonucu doğrulayın, varsayımları unutmayın</h2>

<p>Optimumu ayrıca kısa bir matematiksel kontrolle doğrulayabiliriz. İşçilik kısıtını $0{,}4$, makine kısıtını $0{,}2$ ile çarpıp topladığımızda:</p>

\[x+y\le0{,}4(100)+0{,}2(90)=58\]

<p>Bulduğumuz plan bu üst sınıra ulaştığı için optimaldir. Bu katsayılar, mevcut çözüm yapısı değişmediği sürece ek kapasitenin marjinal etkisini de gösterir: Bir saat işçilik yaklaşık $0{,}4$, bir saat makine kapasitesi $0{,}2$ ek ürün sağlar.</p>

<p>Son olarak, standart lineer programlama kesirli üretime izin verir. Burada sonuç tesadüfen tam sayıdır. Bölünemeyen ürünlerde genel çözüm için tamsayılı programlama gerekir; sonucu gelişigüzel yuvarlamak kısıtları bozabilir. Güvenilir üretim planı, yalnızca iyi bir çözücü değil, gerçekçi veriler ve doğru varsayımlar da ister.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Proje" /><category term="lineer programlama" /><category term="üretim planlama" /><category term="optimizasyon" /><category term="python" /><category term="scipy" /><category term="matematiksel modelleme" /><summary type="html"><![CDATA[Bir fabrikanın elinde sınırlı işçilik ve makine süresi varsa, hangi üründen kaç adet üretmesi gerekir? Sezgiler başlangıç için güzeldir; ancak kaynaklar daraldığında matematik daha iyi bir vardiya şefi olabilir. Lineer programlama, üretim kararlarını ölçülebilir bir modele dönüştürerek mümkün olan en yüksek çıktıyı bulmamızı sağlar.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/lineer-programlama-ile-13.png" /><media:content medium="image" url="https://program.sonsuz.us/img/lineer-programlama-ile-13.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Meydanlardan Stadyumlara: Yaya Simülasyonlarıyla Kalabalığın Akışını Tasarlamak</title><link href="https://program.sonsuz.us/posts/meydanlardan-stadyumlara-yaya-simulasyonlariyla-kalabaligin-akisini-tasarlamak/" rel="alternate" type="text/html" title="Meydanlardan Stadyumlara: Yaya Simülasyonlarıyla Kalabalığın Akışını Tasarlamak" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/meydanlardan-stadyumlara-yaya-simulasyonlariyla-kalabaligin-akisini-tasarlamak</id><content type="html" xml:base="https://program.sonsuz.us/posts/meydanlardan-stadyumlara-yaya-simulasyonlariyla-kalabaligin-akisini-tasarlamak/"><![CDATA[<p>Bir stadyumun kapısını birkaç metre genişletmek gerçekten tahliyeyi hızlandırır mı? Meydandaki büfeyi başka yere taşımak sıkışıklığı azaltır mı? Yaya hareketliliği simülasyonları, bu soruları inşaat başlamadan araştırmamızı sağlar. Üstelik mesele ekranda yürüyen sevimli noktalar değildir: Her nokta, kararları ve fiziksel sınırları olan bir insanı temsil eder.</p>

<p>``</p>

<h2 id="kalabalık-tek-bir-büyük-karakter-değildir">Kalabalık, tek bir büyük karakter değildir</h2>

<p>Ajan tabanlı modellerde her yaya bağımsız bir hesaplama birimidir. Konumu, hızı, hedefi ve tercihleri bulunur. Kalabalığın genel davranışı, bu küçük birimlerin etkileşiminden doğar. Karşılıklı yürüyen insanların kendiliğinden şerit oluşturması, bunun güzel örneklerinden biridir.</p>

<p>Yaygın yaklaşımlardan <strong>sosyal kuvvet modeli</strong>, hareketi hedefe ilerleme isteği ve çevreden gelen etkilerle açıklar:</p>

\[m_i a_i=\frac{m_i(v_i^0 e_i-v_i)}{\tau_i}+\sum_{j\ne i}F_{ij}+F_{i,\mathrm{duvar}}\]

<p>Burada $v_i^0$ istenen sürat, $e_i$ hedef yönü, $\tau_i$ tepki süresidir. Diğer terimler, yayaların ve duvarların etkisini temsil eder. Bunlar psikolojik davranışın birebir fizik yasaları değil, ölçümlerle ayarlanması gereken model bileşenleridir.</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Temel mantık</th>
      <th>Tasarımdaki kullanım</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Sosyal kuvvet</td>
      <td>Sürekli konum ve etkileşim</td>
      <td>Kapı çevresindeki hareket</td>
    </tr>
    <tr>
      <td>Hücresel otomat</td>
      <td>Izgarada hücre değiştirme</td>
      <td>Çok sayıda senaryoyu tarama</td>
    </tr>
    <tr>
      <td>Hız engelleri</td>
      <td>Çarpışma oluşturacak hızlardan kaçınma</td>
      <td>Yerel hareket planlama</td>
    </tr>
  </tbody>
</table>

<h2 id="geniş-kapı-neden-her-zaman-çözüm-değildir">Geniş kapı neden her zaman çözüm değildir?</h2>

<p>Akış yalnızca kapının genişliğine bağlı değildir. Yoğunluk arttığında insanlar daha yavaş ilerleyebilir. Birim genişlik başına akış için temel ilişki şöyledir:</p>

\[J_s=\rho v,\qquad Q=wJ_s\]

<p>Burada $\rho$ kişi/metrekare, $v$ metre/saniye, $w$ geçiş genişliğidir; $Q$ kişi/saniye olarak ölçülür. Bu ilişki muhasebe açısından yararlıdır, ancak hızın yoğunlukla nasıl değiştiğini ayrıca modellemek gerekir. Geniş kapının arkasındaki dar koridor, darboğazı sadece birkaç metre ileri taşıyabilir. Kalabalık, tasarım hatasını sihirli biçimde buharlaştırmaz!</p>

<h2 id="python-ile-küçük-bir-hareket-çekirdeği">Python ile küçük bir hareket çekirdeği</h2>

<p>Aşağıdaki NumPy kodu, hedefe yönelme ve yayalar arasında uzaklaşma eğilimini hesaplar. <code class="language-plaintext highlighter-rouge">pos</code>, <code class="language-plaintext highlighter-rouge">vel</code> ve <code class="language-plaintext highlighter-rouge">goals</code>, her satırı bir yayaya karşılık gelen <code class="language-plaintext highlighter-rouge">(N, 2)</code> dizileridir.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">numpy</span> <span class="k">as</span> <span class="n">np</span>


<span class="k">def</span> <span class="nf">step</span><span class="p">(</span><span class="n">pos</span><span class="p">,</span> <span class="n">vel</span><span class="p">,</span> <span class="n">goals</span><span class="p">,</span> <span class="n">dt</span><span class="o">=</span><span class="mf">0.05</span><span class="p">):</span>
    <span class="n">target</span> <span class="o">=</span> <span class="n">goals</span> <span class="o">-</span> <span class="n">pos</span>
    <span class="n">distance</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="n">linalg</span><span class="p">.</span><span class="nf">norm</span><span class="p">(</span><span class="n">target</span><span class="p">,</span> <span class="n">axis</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
    <span class="n">direction</span> <span class="o">=</span> <span class="n">target</span> <span class="o">/</span> <span class="p">(</span><span class="n">distance</span><span class="p">[:,</span> <span class="bp">None</span><span class="p">]</span> <span class="o">+</span> <span class="mf">1e-9</span><span class="p">)</span>
    <span class="n">desired_speed</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="nf">minimum</span><span class="p">(</span><span class="mf">1.3</span><span class="p">,</span> <span class="n">distance</span> <span class="o">/</span> <span class="mf">0.5</span><span class="p">)</span>
    <span class="n">desired</span> <span class="o">=</span> <span class="n">direction</span> <span class="o">*</span> <span class="n">desired_speed</span><span class="p">[:,</span> <span class="bp">None</span><span class="p">]</span>

    <span class="n">delta</span> <span class="o">=</span> <span class="n">pos</span><span class="p">[:,</span> <span class="bp">None</span><span class="p">,</span> <span class="p">:]</span> <span class="o">-</span> <span class="n">pos</span><span class="p">[</span><span class="bp">None</span><span class="p">,</span> <span class="p">:,</span> <span class="p">:]</span>
    <span class="n">gap</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="n">linalg</span><span class="p">.</span><span class="nf">norm</span><span class="p">(</span><span class="n">delta</span><span class="p">,</span> <span class="n">axis</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
    <span class="n">normal</span> <span class="o">=</span> <span class="n">delta</span> <span class="o">/</span> <span class="p">(</span><span class="n">gap</span><span class="p">[:,</span> <span class="p">:,</span> <span class="bp">None</span><span class="p">]</span> <span class="o">+</span> <span class="mf">1e-9</span><span class="p">)</span>
    <span class="n">strength</span> <span class="o">=</span> <span class="mf">2.0</span> <span class="o">*</span> <span class="n">np</span><span class="p">.</span><span class="nf">exp</span><span class="p">(</span>
        <span class="n">np</span><span class="p">.</span><span class="nf">clip</span><span class="p">((</span><span class="mf">0.5</span> <span class="o">-</span> <span class="n">gap</span><span class="p">)</span> <span class="o">/</span> <span class="mf">0.3</span><span class="p">,</span> <span class="o">-</span><span class="mi">30</span><span class="p">,</span> <span class="mi">10</span><span class="p">)</span>
    <span class="p">)</span>
    <span class="n">np</span><span class="p">.</span><span class="nf">fill_diagonal</span><span class="p">(</span><span class="n">strength</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">)</span>
    <span class="n">repulsion</span> <span class="o">=</span> <span class="p">(</span><span class="n">strength</span><span class="p">[:,</span> <span class="p">:,</span> <span class="bp">None</span><span class="p">]</span> <span class="o">*</span> <span class="n">normal</span><span class="p">).</span><span class="nf">sum</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>

    <span class="n">acceleration</span> <span class="o">=</span> <span class="p">(</span><span class="n">desired</span> <span class="o">-</span> <span class="n">vel</span><span class="p">)</span> <span class="o">/</span> <span class="mf">0.5</span> <span class="o">+</span> <span class="n">repulsion</span>
    <span class="n">new_vel</span> <span class="o">=</span> <span class="n">vel</span> <span class="o">+</span> <span class="n">acceleration</span> <span class="o">*</span> <span class="n">dt</span>
    <span class="n">speed</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="n">linalg</span><span class="p">.</span><span class="nf">norm</span><span class="p">(</span><span class="n">new_vel</span><span class="p">,</span> <span class="n">axis</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
    <span class="n">new_vel</span> <span class="o">*=</span> <span class="n">np</span><span class="p">.</span><span class="nf">minimum</span><span class="p">(</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">2.0</span> <span class="o">/</span> <span class="p">(</span><span class="n">speed</span> <span class="o">+</span> <span class="mf">1e-9</span><span class="p">))[:,</span> <span class="bp">None</span><span class="p">]</span>
    <span class="k">return</span> <span class="n">pos</span> <span class="o">+</span> <span class="n">new_vel</span> <span class="o">*</span> <span class="n">dt</span><span class="p">,</span> <span class="n">new_vel</span>
</code></pre></div></div>

<p>İlk bölüm hedef yakınında yavaşlamayı sağlar. İkinci bölüm, yakın komşuların uzaklaşma etkisini toplar; son bölüm hareketi günceller. Sabitler örnek parametrelerdir, güvenlik sınırları değildir. Kod duvarları, fiziksel teması ve rota planlamasını içermez; çarpışmasız hareket garantilemez. Ayrıca tüm çiftleri karşılaştırdığı için maliyeti $O(N^2)$ olur. Büyük kalabalıklarda uzamsal indeksleme gerekir.</p>

<h2 id="tasarımı-karşılaştırmalı-bir-deneye-dönüştürmek">Tasarımı karşılaştırmalı bir deneye dönüştürmek</h2>

<p>Meydan veya stadyum geometrisini modele aktardıktan sonra tek bir animasyona bakıp karar vermeyin. Aynı koşullarda farklı tasarımları karşılaştırın:</p>

<ol>
  <li><strong>Başlangıcı tanımlayın:</strong> Giriş hızlarını, hedef dağılımını ve yürüme hızlarındaki çeşitliliği belirleyin. Arkadaş gruplarını ve erişilebilir güzergâhları unutmayın.</li>
  <li><strong>Alternatifler üretin:</strong> Kapı genişliği, bariyer yerleşimi ve büfe konumu gibi değişkenleri ayrı ayrı değiştirin.</li>
  <li><strong>Ölçün:</strong> Tahliye süresini, yerel yoğunluğu, bekleme sürelerini ve çıkış çizgisini geçen kişi sayısını kaydedin.</li>
  <li><strong>Tekrarlayın:</strong> Farklı başlangıç dağılımlarıyla çoklu koşular yapın; yalnızca ortalamayı değil, sonuçların değişkenliğini de raporlayın.</li>
</ol>

<p>Rota seçimi için en kısa yol her zaman en hızlı yol değildir. Algoritma, mesafeyle birlikte beklenen sıkışıklığı değerlendirebilir. Ancak çok sık rota değiştirmek kararsızlığa yol açabilir; karar güncellemelerini yumuşatmak faydalıdır.</p>

<h2 id="animasyon-güzel-doğrulama-daha-güzel">Animasyon güzel, doğrulama daha güzel</h2>

<p>Modeli gerçek sayımlar, anonimleştirilmiş hareket ölçümleri ve geçiş süreleriyle kalibre edin. Parametre duyarlılığını ve zaman adımı küçültüldüğünde sonuçların değişip değişmediğini inceleyin. Simülasyon, tasarımlar arasındaki farkları görünür kılan güçlü bir deney aracıdır; mevzuatın, saha incelemesinin veya uzman güvenlik değerlendirmesinin yerine geçmez.</p>

<p><img src="/img/meydanlardan-stadyumlara-yaya-16.svg" alt="meydanlardan-stadyumlara-yaya-16" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="simülasyon" /><category term="kalabalık yönetimi" /><category term="python" /><category term="ajan tabanlı modelleme" /><category term="şehir tasarımı" /><summary type="html"><![CDATA[Bir stadyumun kapısını birkaç metre genişletmek gerçekten tahliyeyi hızlandırır mı? Meydandaki büfeyi başka yere taşımak sıkışıklığı azaltır mı? Yaya hareketliliği simülasyonları, bu soruları inşaat başlamadan araştırmamızı sağlar. Üstelik mesele ekranda yürüyen sevimli noktalar değildir: Her nokta, kararları ve fiziksel sınırları olan bir insanı temsil eder.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/meydanlardan-stadyumlara-yaya-16.png" /><media:content medium="image" url="https://program.sonsuz.us/img/meydanlardan-stadyumlara-yaya-16.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">MOOC Altyapısı: Milyonlarca Öğrenciye Aynı Anda Ders Vermek</title><link href="https://program.sonsuz.us/posts/mooc-altyapisi-milyonlarca-ogrenciye-ayni-anda-ders-vermek/" rel="alternate" type="text/html" title="MOOC Altyapısı: Milyonlarca Öğrenciye Aynı Anda Ders Vermek" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/mooc-altyapisi-milyonlarca-ogrenciye-ayni-anda-ders-vermek</id><content type="html" xml:base="https://program.sonsuz.us/posts/mooc-altyapisi-milyonlarca-ogrenciye-ayni-anda-ders-vermek/"><![CDATA[<p><img src="/img/mooc-altyapisi-milyonlarca-98.svg" alt="mooc-altyapisi-milyonlarca-98" /></p>

<p>Bir milyon öğrencinin aynı anda ders izlediğini düşünün: Videolar akıyor, sınavlar teslim ediliyor, ilerleme bilgileri kaydediliyor. Bu kalabalığı tek bir güçlü sunucuya emanet etmek, stadyumdaki herkese tek musluktan su dağıtmaya benzer. MOOC altyapısının sırrı, yalnızca daha fazla makine kullanmak değil; işleri doğru parçalara ayırmaktır.</p>

<p>``</p>

<h2 id="önce-kalabalığı-matematiğe-çevirelim">Önce kalabalığı matematiğe çevirelim</h2>

<p>Çevrimiçi öğrenci sayısı, eşzamanlı API isteği sayısıyla aynı değildir. Bir milyon öğrenci ortalama yirmi saniyede bir API isteği gönderiyorsa geliş hızı yaklaşık $\lambda = 50.000$ istek/saniyedir.</p>

<p>Kararlı bir sistemde Little Yasası, ortalama sistemdeki iş sayısını verir:</p>

\[L = \lambda W\]

<p>Ortalama yanıt süresi $W = 0{,}2$ saniyeyse, aynı anda işlenen veya bekleyen yaklaşık $10.000$ istek bulunur. Buradaki değerler aynı ölçüm sınırına ait uzun dönem ortalamalarıdır; kuyruk sürekli büyüyorsa kararlılık varsayımı bozulur.</p>

<p>Video tarafında tablo farklıdır: Öğrenci başına ortalama 2 Mbps, bir milyon eşzamanlı izleyicide yaklaşık 2 Tbps trafik demektir. Dolayısıyla uygulama sunucularını büyütmek, video dağıtım sorununu tek başına çözmez.</p>

<h2 id="video-ile-uygulamayı-ayırın">Video ile uygulamayı ayırın</h2>

<p>Videolar nesne depolamada tutulur; farklı çözünürlüklerde kodlanıp HLS veya DASH parçaları olarak CDN üzerinden dağıtılır. Uyarlanabilir yayın, bağlantı yavaşladığında kaliteyi düşürerek kesintiyi azaltır. Popüler içerikler uç noktalarda önbelleğe alınır; başlangıç sunucusuna binen yük düşer.</p>

<table>
  <thead>
    <tr>
      <th>Trafik türü</th>
      <th>Uygun yaklaşım</th>
      <th>Temel kazanım</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Video parçaları</td>
      <td>CDN ve nesne depolama</td>
      <td>Bant genişliğini dağıtmak</td>
    </tr>
    <tr>
      <td>Ders kataloğu</td>
      <td>Önbellek ve API</td>
      <td>Tekrarlanan okumaları azaltmak</td>
    </tr>
    <tr>
      <td>Sınav teslimi</td>
      <td>Dayanıklı, senkron kayıt</td>
      <td>Kritik veriyi korumak</td>
    </tr>
    <tr>
      <td>İzleme olayları</td>
      <td>Mesaj kuyruğu</td>
      <td>Ani yükü yumuşatmak</td>
    </tr>
  </tbody>
</table>

<p>Uygulama servisleri mümkün olduğunca durumsuz tasarlanır. Oturum bilgisini tek makinenin belleğine bağlamamak, yük dengeleyicinin isteği herhangi bir sağlıklı örneğe yönlendirmesini sağlar. Ancak ortak oturum deposu da kapasitesi ölçülmesi gereken bir bileşendir.</p>

<h2 id="kuyruklar-sihirli-kara-delikler-değildir">Kuyruklar sihirli kara delikler değildir</h2>

<p>İlerleme güncellemeleri, bildirimler ve analitik olayları kuyruğa aktarılabilir. Fakat kuyruk kapasite üretmez; zamanı satın alır. Her işçi saniyede $\mu$ olay işliyorsa, $n$ işçi için sürdürülebilir çalışma yaklaşık $\lambda &lt; n\mu$ gerektirir.</p>

<p>Ani yoğunlukta gecikme kabul edilebilir; sürekli kapasite açığında birikim büyür. Bu yüzden yalnızca işlemci kullanımını değil, kuyruk uzunluğunu ve en eski mesajın yaşını da izlemek gerekir. Sınav teslimini ise yalnızca kuyruğa yazıldığı için “kalıcı olarak kaydedildi” saymayın; başarı yanıtı, tanımlanan dayanıklılık garantisine dayanmalıdır.</p>

<h2 id="aynı-mesaj-iki-kez-gelirse">Aynı mesaj iki kez gelirse?</h2>

<p>Birçok mesajlaşma düzeni en az bir kez teslim sunar. İşçi çökerse aynı olay yeniden gelebilir. Aşağıdaki Python örneği, Psycopg ile olay kimliğini ve ilerlemeyi aynı PostgreSQL işlemi içinde kaydeder:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">save_progress</span><span class="p">(</span><span class="n">conn</span><span class="p">,</span> <span class="n">event</span><span class="p">):</span>
    <span class="k">with</span> <span class="n">conn</span><span class="p">.</span><span class="nf">transaction</span><span class="p">():</span>
        <span class="n">inserted</span> <span class="o">=</span> <span class="n">conn</span><span class="p">.</span><span class="nf">execute</span><span class="p">(</span>
            <span class="sh">'''</span><span class="s">INSERT INTO processed_event (event_id)
               VALUES (%s)
               ON CONFLICT DO NOTHING
               RETURNING event_id</span><span class="sh">'''</span><span class="p">,</span>
            <span class="p">(</span><span class="n">event</span><span class="p">[</span><span class="sh">'</span><span class="s">id</span><span class="sh">'</span><span class="p">],)</span>
        <span class="p">).</span><span class="nf">fetchone</span><span class="p">()</span>

        <span class="k">if</span> <span class="n">inserted</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">:</span>
            <span class="k">return</span>

        <span class="n">conn</span><span class="p">.</span><span class="nf">execute</span><span class="p">(</span>
            <span class="sh">'''</span><span class="s">INSERT INTO progress (user_id, video_id, max_seconds)
               VALUES (%s, %s, %s)
               ON CONFLICT (user_id, video_id) DO UPDATE
               SET max_seconds = GREATEST(
                   progress.max_seconds, EXCLUDED.max_seconds)</span><span class="sh">'''</span><span class="p">,</span>
            <span class="p">(</span><span class="n">event</span><span class="p">[</span><span class="sh">'</span><span class="s">user_id</span><span class="sh">'</span><span class="p">],</span> <span class="n">event</span><span class="p">[</span><span class="sh">'</span><span class="s">video_id</span><span class="sh">'</span><span class="p">],</span> <span class="n">event</span><span class="p">[</span><span class="sh">'</span><span class="s">seconds</span><span class="sh">'</span><span class="p">])</span>
        <span class="p">)</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">processed_event.event_id</code> birincil anahtar; ilerleme tablosundaki kullanıcı-video çifti benzersiz olmalıdır. Böylece tekrarlar elenir, sırası değişen olaylar en yüksek izlenen konumu geriye götürmez. Bu değer, kullanıcının son oynatma konumuyla aynı şey değildir. Kuyruk mesajı, veritabanı işlemi başarıyla tamamlandıktan sonra onaylanır. Olay kimliklerinin saklama süresi de yeniden teslim penceresine göre belirlenmelidir.</p>

<h2 id="darboğazı-başka-yere-taşımayın">Darboğazı başka yere taşımayın</h2>

<p>API örneklerini çoğaltmak, veritabanına sınırsız bağlantı açmak anlamına gelmemelidir. Bağlantı havuzları, doğru indeksler ve gerektiğinde kullanıcı kimliğine göre bölümleme önemlidir. Okuma kopyaları faydalıdır; fakat gecikmeli çoğaltma yüzünden yeni teslim edilen sınav hemen görünmeyebilir.</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Risk</th>
      <th>Daha güvenli seçenek</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Sınırsız yeniden deneme</td>
      <td>Trafik fırtınası</td>
      <td>Gecikmeli, rastgeleleştirilmiş tekrar</td>
    </tr>
    <tr>
      <td>Her şeyi önbellekleme</td>
      <td>Eski veya sızan veri</td>
      <td>Süre, geçersizleştirme ve kullanıcı ayrımı</td>
    </tr>
    <tr>
      <td>Yalnızca CPU ile ölçekleme</td>
      <td>Kuyruk gecikmesini kaçırma</td>
      <td>Gecikme ve birikimi birlikte izleme</td>
    </tr>
  </tbody>
</table>

<h2 id="başarıyı-öğrenci-deneyimiyle-ölçün">Başarıyı öğrenci deneyimiyle ölçün</h2>

<p>Ortalama gecikme tek başına yeterli değildir. p95/p99 yanıt sürelerini, video başlangıç süresini, takılma oranını ve teslim hatalarını takip edin. Planlı sınavlar öncesinde kapasiteyi ısıtın; yük testlerinde önbellek kaçırmalarını ve servis arızalarını da deneyin.</p>

<p>Kaynaklar daraldığında öneri sistemini yavaşlatmak, sınav teslimini kaybetmekten iyidir. İmzalı video bağlantıları, yetkilendirme, hız sınırları ve kişisel verilerin korunması da tasarımın parçasıdır. Gerçek ölçeklenebilirlik, milyonlara hizmet verirken tek bir öğrencinin deneyimini unutmamaktır.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="mooc" /><category term="ölçeklenebilirlik" /><category term="dağıtık sistemler" /><category term="bulut" /><category term="cdn" /><category term="mesaj kuyrukları" /><summary type="html"><![CDATA[Bir milyon öğrencinin aynı anda ders izlediğini düşünün: Videolar akıyor, sınavlar teslim ediliyor, ilerleme bilgileri kaydediliyor. Bu kalabalığı tek bir güçlü sunucuya emanet etmek, stadyumdaki herkese tek musluktan su dağıtmaya benzer. MOOC altyapısının sırrı, yalnızca daha fazla makine kullanmak değil; işleri doğru parçalara ayırmaktır.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/mooc-altyapisi-milyonlarca-98.png" /><media:content medium="image" url="https://program.sonsuz.us/img/mooc-altyapisi-milyonlarca-98.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry></feed>