<?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-02T12:05:55+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">Ç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">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">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">Şehrin Geleceğini Önce Simüle Edelim: Katılımcı Planlamada Karar Destek Araçları</title><link href="https://program.sonsuz.us/posts/sehrin-gelecegini-once-simule-edelim-katilimci-planlamada-karar-destek-araclari/" rel="alternate" type="text/html" title="Şehrin Geleceğini Önce Simüle Edelim: Katılımcı Planlamada Karar Destek Araçları" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/sehrin-gelecegini-once-simule-edelim-katilimci-planlamada-karar-destek-araclari</id><content type="html" xml:base="https://program.sonsuz.us/posts/sehrin-gelecegini-once-simule-edelim-katilimci-planlamada-karar-destek-araclari/"><![CDATA[<p>Mahallenizdeki otoparkın parka dönüştürülmesini önerdiniz. Harika! Peki trafik, erişilebilirlik ve belediye bütçesi bundan nasıl etkilenir? Katılımcı şehir planlamasında simülasyon tabanlı karar destek araçları, vatandaş fikirlerini ölçülebilir senaryolara dönüştürür. Böylece tartışma, “Bence güzel olur” seviyesinden “Hangi koşullarda, kimler için güzel olur?” seviyesine taşınır. Şehir, pahalı değişikliklerden önce dijital bir prova yapar.</p>

<p><img src="/img/sehrin-gelecegini-once-74.svg" alt="sehrin-gelecegini-once-74" /></p>

<p>``</p>

<h2 id="vatandaş-fikrinden-çalıştırılabilir-senaryoya">Vatandaş fikrinden çalıştırılabilir senaryoya</h2>

<p>Yazılım, “Daha yaşanabilir bir sokak istiyoruz” cümlesini doğrudan hesaplayamaz. Önce önerinin konumu, kapsamı ve beklenen davranış değişikliği tanımlanmalıdır. Örneğin bir bisiklet yolu önerisi; yol kapasitesi, bisiklete geçiş oranı, kavşak düzeni ve yatırım maliyeti gibi parametrelere ayrılır.</p>

<p>Burada vatandaş yalnızca fikir veren kişi değildir: Senaryonun varsayımlarını doğrulayan bir ortak tasarımcıdır. “Bu güzergâh okul saatinde kalabalıklaşıyor” bilgisi, günlük ortalamaların gizlediği önemli bir ayrıntıyı ortaya çıkarabilir.</p>

<table>
  <thead>
    <tr>
      <th>Vatandaş önerisi</th>
      <th>Modeldeki karşılığı</th>
      <th>İzlenecek gösterge</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Bisiklet yolu açılsın</td>
      <td>Kapasite ve ulaşım tercihi değişimi</td>
      <td>Yolculuk süresi, güvenlik</td>
    </tr>
    <tr>
      <td>Otobüs seferleri artırılsın</td>
      <td>Sefer aralığı ve araç kapasitesi</td>
      <td>Bekleme, erişilebilirlik</td>
    </tr>
    <tr>
      <td>Otopark parka dönüşsün</td>
      <td>Arazi kullanımı değişimi</td>
      <td>Yeşil alana erişim, maliyet</td>
    </tr>
  </tbody>
</table>

<h2 id="simülasyonun-teorik-motoru">Simülasyonun teorik motoru</h2>

<p>Bir simülasyon; sistemin durumunu, aktörlerini ve zaman içindeki değişimini temsil eder. Ajan tabanlı modellerde insanlar farklı tercihlerle hareket ederken, trafik modelleri araç akışını ve kuyruk oluşumunu hesaplayabilir. SUMO ulaşım simülasyonu, Mesa ise ajan tabanlı deneyler için değerlendirilebilecek araçlardır.</p>

<p>Basitleştirilmiş bir yol bağlantısında seyahat süresi, BPR fonksiyonuyla modellenebilir:</p>

\[t=t_0\left[1+\alpha\left(\frac{v}{c}\right)^\beta\right]\]

<p>Burada $t_0$ serbest akış süresi, $v$ araç akışı, $c$ kapasitedir. $\alpha$ ve $\beta$ yerel ölçümlerle kalibre edilmelidir. Temel fikir şudur: Kapasiteye yaklaşırken gecikme doğrusal artmak zorunda değildir. Ancak bu formül tek başına kavşakları, kuyruk taşmasını veya bütün ulaşım ağını açıklamaz.</p>

<h2 id="veriden-deney-düzenine">Veriden deney düzenine</h2>

<p>Önce mevcut durum modeli kurulur; yol ağı, nüfus, seferler ve anonimleştirilmiş sayımlar birleştirilir. Model, ayrı tutulan gözlemlerle doğrulanır. Ardından her öneri aynı başlangıç koşullarıyla karşılaştırılır. Aksi hâlde yağmurlu pazartesi ile güneşli pazar gününü yarıştırmış oluruz!</p>

<p>Talep belirsizliğini incelemek için Monte Carlo yaklaşımıyla çok sayıda olası gün üretilebilir. Aynı rastgele talepleri bütün senaryolarda kullanmak, karşılaştırmadaki gereksiz gürültüyü azaltır.</p>

<h2 id="python-ile-küçük-bir-senaryo-laboratuvarı">Python ile küçük bir senaryo laboratuvarı</h2>

<p>Aşağıdaki örnek, bisiklet yatırımı sonrasında otomobil tercihinin azalabileceği varsayımını test eder. Tam bir şehir modeli değildir; yalnızca tek bağlantının gecikmesini hesaplayan öğretici bir prototiptir.</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="kn">import</span> <span class="n">numpy</span> <span class="k">as</span> <span class="n">np</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">Scenario</span><span class="p">:</span>
    <span class="n">capacity</span><span class="p">:</span> <span class="nb">float</span>  <span class="c1"># araç/saat
</span>    <span class="n">car_share</span><span class="p">:</span> <span class="nb">float</span>

<span class="n">rng</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">default_rng</span><span class="p">(</span><span class="mi">42</span><span class="p">)</span>
<span class="n">demand</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="nf">clip</span><span class="p">(</span><span class="n">rng</span><span class="p">.</span><span class="nf">normal</span><span class="p">(</span><span class="mi">1800</span><span class="p">,</span> <span class="mi">180</span><span class="p">,</span> <span class="mi">1000</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">scenarios</span> <span class="o">=</span> <span class="p">{</span>
    <span class="sh">"</span><span class="s">mevcut</span><span class="sh">"</span><span class="p">:</span> <span class="nc">Scenario</span><span class="p">(</span><span class="mi">1200</span><span class="p">,</span> <span class="mf">0.70</span><span class="p">),</span>
    <span class="sh">"</span><span class="s">bisiklet</span><span class="sh">"</span><span class="p">:</span> <span class="nc">Scenario</span><span class="p">(</span><span class="mi">1000</span><span class="p">,</span> <span class="mf">0.55</span><span class="p">),</span>
<span class="p">}</span>

<span class="k">def</span> <span class="nf">travel_time</span><span class="p">(</span><span class="n">scenario</span><span class="p">:</span> <span class="n">Scenario</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="n">np</span><span class="p">.</span><span class="n">ndarray</span><span class="p">:</span>
    <span class="c1"># Talep kişi/saat; doluluk 1.2 kişi/araç varsayılıyor.
</span>    <span class="n">flow</span> <span class="o">=</span> <span class="n">demand</span> <span class="o">*</span> <span class="n">scenario</span><span class="p">.</span><span class="n">car_share</span> <span class="o">/</span> <span class="mf">1.2</span>
    <span class="k">return</span> <span class="mi">12</span> <span class="o">*</span> <span class="p">(</span><span class="mi">1</span> <span class="o">+</span> <span class="mf">0.15</span> <span class="o">*</span> <span class="p">(</span><span class="n">flow</span> <span class="o">/</span> <span class="n">scenario</span><span class="p">.</span><span class="n">capacity</span><span class="p">)</span> <span class="o">**</span> <span class="mi">4</span><span class="p">)</span>

<span class="n">baseline</span> <span class="o">=</span> <span class="nf">travel_time</span><span class="p">(</span><span class="n">scenarios</span><span class="p">[</span><span class="sh">"</span><span class="s">mevcut</span><span class="sh">"</span><span class="p">])</span>
<span class="k">for</span> <span class="n">name</span><span class="p">,</span> <span class="n">scenario</span> <span class="ow">in</span> <span class="n">scenarios</span><span class="p">.</span><span class="nf">items</span><span class="p">():</span>
    <span class="n">times</span> <span class="o">=</span> <span class="nf">travel_time</span><span class="p">(</span><span class="n">scenario</span><span class="p">)</span>
    <span class="n">delta</span> <span class="o">=</span> <span class="n">times</span> <span class="o">-</span> <span class="n">baseline</span>
    <span class="nf">print</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="p">{</span>
        <span class="sh">"</span><span class="s">ortalama_dakika</span><span class="sh">"</span><span class="p">:</span> <span class="nf">round</span><span class="p">(</span><span class="nf">float</span><span class="p">(</span><span class="n">times</span><span class="p">.</span><span class="nf">mean</span><span class="p">()),</span> <span class="mi">2</span><span class="p">),</span>
        <span class="sh">"</span><span class="s">p95_dakika</span><span class="sh">"</span><span class="p">:</span> <span class="nf">round</span><span class="p">(</span><span class="nf">float</span><span class="p">(</span><span class="n">np</span><span class="p">.</span><span class="nf">percentile</span><span class="p">(</span><span class="n">times</span><span class="p">,</span> <span class="mi">95</span><span class="p">)),</span> <span class="mi">2</span><span class="p">),</span>
        <span class="sh">"</span><span class="s">iyilesme_orani</span><span class="sh">"</span><span class="p">:</span> <span class="nf">round</span><span class="p">(</span><span class="nf">float</span><span class="p">(</span><span class="n">np</span><span class="p">.</span><span class="nf">mean</span><span class="p">(</span><span class="n">delta</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">)),</span> <span class="mi">3</span><span class="p">),</span>
    <span class="p">})</span>
</code></pre></div></div>

<p>Kod, bin talep örneğinde ortalama süreyi, yüzde 95’lik dilimi ve mevcut duruma göre iyileşme oranını raporlar. Buradaki yüzde 95’lik dilim bir güven aralığı değildir. Otomobil payları, doluluk ve kapasite değerleri varsayımsaldır; sonuçlar gerçek bir yatırımın başarısını kanıtlamaz. Özellikle otomobilden bisiklete geçiş oranı farklı değerlerle tekrar denenmelidir. Ayrıca hesaplanan süre yalnızca otomobillerin bu bağlantıdaki süresidir.</p>

<h2 id="tek-puan-mı-şeffaf-karşılaştırma-mı">Tek puan mı, şeffaf karşılaştırma mı?</h2>

<p>Karar desteği trafik hızından ibaret olmamalıdır. Çevresel fayda, erişilebilirlik, dağıtımsal adalet ve bütçeye uygunluk birlikte değerlendirilebilir:</p>

\[S=0.35E+0.25A+0.25D+0.15K\]

<p>Burada bütün göstergeler $[0,1]$ aralığına dönüştürülür ve yüksek değer daha iyi durumu gösterir. Ağırlıklar teknik gerçek değil, toplumsal tercihtir. Bu yüzden katılımcılar ağırlıkları değiştirebilmeli; uygulama toplam puanın yanında ham ölçümleri, mahalle bazındaki etkileri ve hangi seçeneğin hangi ölçütte üstün olduğunu göstermelidir.</p>

<h2 id="güvenilir-katılımın-kontrol-listesi">Güvenilir katılımın kontrol listesi</h2>

<p>Çevrim içi öneriler bütün nüfusu temsil etmeyebilir. Yüz yüze toplantılar, erişilebilir arayüzler ve farklı mahallelerden katılım bu açığı azaltır. Sonuçlar gelir, yaş ve engellilik açısından dağıtımsal etkilerle incelenmeli; hassas bilgiler korunmalıdır. Varsayımlar, veri tarihleri ve model sürümleri kaydedilmelidir. Ayrıca inşaat dönemi gibi geçici etkiler unutulmamalıdır.</p>

<p>Sonuçta iyi bir karar destek aracı belediye başkanı rolüne soyunmaz. Alternatifleri görünür kılar, belirsizliği açıklar ve vatandaşların gerekçeli tartışmasını güçlendirir. En değerli çıktı, tek bir kazanan değil; birlikte anlaşılmış bir karar sürecidir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="şehir planlama" /><category term="katılımcı tasarım" /><category term="simülasyon" /><category term="python" /><category term="karar destek" /><category term="açık veri" /><summary type="html"><![CDATA[Mahallenizdeki otoparkın parka dönüştürülmesini önerdiniz. Harika! Peki trafik, erişilebilirlik ve belediye bütçesi bundan nasıl etkilenir? Katılımcı şehir planlamasında simülasyon tabanlı karar destek araçları, vatandaş fikirlerini ölçülebilir senaryolara dönüştürür. Böylece tartışma, “Bence güzel olur” seviyesinden “Hangi koşullarda, kimler için güzel olur?” seviyesine taşınır. Şehir, pahalı değişikliklerden önce dijital bir prova yapar.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/sehrin-gelecegini-once-74.png" /><media:content medium="image" url="https://program.sonsuz.us/img/sehrin-gelecegini-once-74.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Şehrin Sıcak Noktalarını Bulmak: Uydu ve Sensör Verileriyle Kentsel Isı Adası Haritalama</title><link href="https://program.sonsuz.us/posts/sehrin-sicak-noktalarini-bulmak-uydu-ve-sensor-verileriyle-kentsel-isi-adasi-haritalama/" rel="alternate" type="text/html" title="Şehrin Sıcak Noktalarını Bulmak: Uydu ve Sensör Verileriyle Kentsel Isı Adası Haritalama" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/sehrin-sicak-noktalarini-bulmak-uydu-ve-sensor-verileriyle-kentsel-isi-adasi-haritalama</id><content type="html" xml:base="https://program.sonsuz.us/posts/sehrin-sicak-noktalarini-bulmak-uydu-ve-sensor-verileriyle-kentsel-isi-adasi-haritalama/"><![CDATA[<p>Yazın aynı şehirde bir park serinletirken asfalt bir meydan neden fırın gibi hissettirir? Cevap yalnızca güneşte değil; yapı malzemelerinde, bitki örtüsünde ve hava dolaşımında saklıdır. Uydu görüntülerini yer sensörleriyle birleştirerek bu farkları ölçebilir, şehrin termal dedektifi olabiliriz. Ancak güzel bir harita çizmeden önce, hangi sıcaklığı ölçtüğümüzü anlamamız gerekir.</p>

<p><img src="/img/sehrin-sicak-noktalarini-58.svg" alt="sehrin-sicak-noktalarini-58" /></p>

<p>``</p>

<h2 id="isı-adasının-fiziksel-mantığı">Isı adasının fiziksel mantığı</h2>

<p>Kentsel ısı adası, kentlerin çevresindeki kırsal alanlardan daha sıcak olmasıdır. Beton ve asfalt güneş enerjisini depolar; azalan bitki örtüsü, buharlaşma ve terleme yoluyla soğutmayı sınırlar. Binalar hava akışını değiştirirken trafik ve klimalar ek ısı üretir. Gece olduğunda depolanan enerji yavaşça salınır. Yani şehir, gündüz şarj olan dev bir termal batarya gibi davranabilir.</p>

<p>Hava sıcaklığına dayalı etkiyi şöyle tanımlayabiliriz:</p>

\[\Delta T_{hava}(t)=T_{kent}(t)-T_{kırsal}(t)\]

<p>Burada karşılaştırılan ölçümler aynı zaman aralığına ait olmalıdır. Referans alanın rakımı, denize uzaklığı ve arazi kullanımı da sonucu etkiler. Rastgele seçilen tek bir kırsal sensör, bütün karşılaştırmayı yanıltabilir.</p>

<h2 id="uydu-ve-sensör-aynı-şeyi-ölçmez">Uydu ve sensör aynı şeyi ölçmez</h2>

<p>Termal uydu ürünleri <strong>yüzey sıcaklığını</strong>, uygun yerleştirilmiş meteorolojik sensörler ise <strong>hava sıcaklığını</strong> temsil eder. Güneşteki asfalt yüzeyiyle iki metre yükseklikteki hava arasında ciddi fark olabilir. Bu nedenle ikisini tek sıcaklık sütununda karıştırmak, elmayla tost makinesini karşılaştırmaya benzer.</p>

<table>
  <thead>
    <tr>
      <th>Veri kaynağı</th>
      <th>Temel ölçüm</th>
      <th>Güçlü tarafı</th>
      <th>Sınırlaması</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Landsat 8/9 termal ürünleri</td>
      <td>Yüzey sıcaklığı</td>
      <td>Şehir genelinde karşılaştırma</td>
      <td>Bulutlar ve seyrek geçişler</td>
    </tr>
    <tr>
      <td>Sentinel-2</td>
      <td>Yansıtım ve bitki örtüsü</td>
      <td>Yeşil alanları ayrıştırma</td>
      <td>Doğrudan termal ölçüm yapmaz</td>
    </tr>
    <tr>
      <td>Yer sensörleri</td>
      <td>Hava sıcaklığı</td>
      <td>Sık zamanlı gözlem</td>
      <td>Konum ve kurulum yanlılığı</td>
    </tr>
  </tbody>
</table>

<p>Landsat termal bantlarının doğal çözünürlüğü yaklaşık 100 metredir; 30 metrelik ürün pikseli, bağımsız 30 metrelik termal ayrıntı anlamına gelmez.</p>

<p>Bitki örtüsünü incelemek için Sentinel-2 üzerinden şu gösterge hesaplanabilir:</p>

\[NDVI=\frac{NIR-Red}{NIR+Red}\]

<p>Yüksek NDVI genellikle daha yoğun bitki örtüsünü gösterir. Ancak düşük sıcaklığın tek açıklaması değildir; gölge, nem ve rüzgâr da önemlidir.</p>

<h2 id="analiz-hattını-hazırlayalım">Analiz hattını hazırlayalım</h2>

<ol>
  <li><strong>Veriyi temizleyin:</strong> Uydu kalite bantlarıyla bulutları maskeleyin. Ürünün ölçek ve ofset bilgilerini uygulayıp sıcaklığı Celsius’a dönüştürün. Sensörlerde hatalı kayıtları ve kalibrasyon sorunlarını kontrol edin.</li>
  <li><strong>Zamanı eşleyin:</strong> Sensörleri gerçek uydu geçişinin çevresindeki dar bir zaman penceresinde özetleyin. Günlük ortalamayla anlık uydu görüntüsünü karşılaştırmayın.</li>
  <li><strong>Mekânı eşleyin:</strong> Verileri aynı, metre birimli yerel koordinat sistemine taşıyın. Örneğin 250 metrelik hücreler oluşturun; bu seçim yeni ayrıntı üretmez.</li>
  <li><strong>Referansı belirleyin:</strong> Birden fazla uygun kırsal istasyonu değerlendirin. Kent ve kırsal sensörlerin benzer koşullarda kurulmasına dikkat edin.</li>
</ol>

<h2 id="python-ile-iki-ayrı-sıcaklık-haritası">Python ile iki ayrı sıcaklık haritası</h2>

<p>Aşağıdaki örnek, hazırlanmış Celsius rasterini hücrelerde özetler ve sensörlerin kırsal referansa göre hava sıcaklığı farkını hesaplar. <code class="language-plaintext highlighter-rouge">geopandas</code>, <code class="language-plaintext highlighter-rouge">pandas</code>, <code class="language-plaintext highlighter-rouge">rasterstats</code> ve <code class="language-plaintext highlighter-rouge">matplotlib</code> gerekir. Grid ile raster aynı koordinat sisteminde olmalıdır.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">geopandas</span> <span class="k">as</span> <span class="n">gpd</span>
<span class="kn">import</span> <span class="n">pandas</span> <span class="k">as</span> <span class="n">pd</span>
<span class="kn">import</span> <span class="n">matplotlib.pyplot</span> <span class="k">as</span> <span class="n">plt</span>
<span class="kn">from</span> <span class="n">rasterstats</span> <span class="kn">import</span> <span class="n">zonal_stats</span>

<span class="n">grid</span> <span class="o">=</span> <span class="n">gpd</span><span class="p">.</span><span class="nf">read_file</span><span class="p">(</span><span class="sh">'</span><span class="s">grid_250m.gpkg</span><span class="sh">'</span><span class="p">)</span>
<span class="n">obs</span> <span class="o">=</span> <span class="n">pd</span><span class="p">.</span><span class="nf">read_csv</span><span class="p">(</span><span class="sh">'</span><span class="s">sensorler.csv</span><span class="sh">'</span><span class="p">)</span>
<span class="n">obs</span><span class="p">[</span><span class="sh">'</span><span class="s">zaman</span><span class="sh">'</span><span class="p">]</span> <span class="o">=</span> <span class="n">pd</span><span class="p">.</span><span class="nf">to_datetime</span><span class="p">(</span><span class="n">obs</span><span class="p">[</span><span class="sh">'</span><span class="s">zaman</span><span class="sh">'</span><span class="p">],</span> <span class="n">utc</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>

<span class="c1"># Gerçek uydu geçiş zamanıyla değiştirin.
</span><span class="n">t</span> <span class="o">=</span> <span class="n">pd</span><span class="p">.</span><span class="nc">Timestamp</span><span class="p">(</span><span class="sh">'</span><span class="s">2026-07-15T08:00:00Z</span><span class="sh">'</span><span class="p">)</span>
<span class="n">obs</span> <span class="o">=</span> <span class="n">obs</span><span class="p">[(</span><span class="n">obs</span><span class="p">[</span><span class="sh">'</span><span class="s">zaman</span><span class="sh">'</span><span class="p">]</span> <span class="o">-</span> <span class="n">t</span><span class="p">).</span><span class="nf">abs</span><span class="p">()</span> <span class="o">&lt;=</span> <span class="n">pd</span><span class="p">.</span><span class="nc">Timedelta</span><span class="p">(</span><span class="sh">'</span><span class="s">15min</span><span class="sh">'</span><span class="p">)]</span>
<span class="n">obs</span> <span class="o">=</span> <span class="n">obs</span><span class="p">.</span><span class="nf">groupby</span><span class="p">(</span>
    <span class="p">[</span><span class="sh">'</span><span class="s">sensor_id</span><span class="sh">'</span><span class="p">,</span> <span class="sh">'</span><span class="s">lon</span><span class="sh">'</span><span class="p">,</span> <span class="sh">'</span><span class="s">lat</span><span class="sh">'</span><span class="p">,</span> <span class="sh">'</span><span class="s">tur</span><span class="sh">'</span><span class="p">],</span> <span class="n">as_index</span><span class="o">=</span><span class="bp">False</span>
<span class="p">).</span><span class="nf">agg</span><span class="p">(</span><span class="n">t_air</span><span class="o">=</span><span class="p">(</span><span class="sh">'</span><span class="s">sicaklik_c</span><span class="sh">'</span><span class="p">,</span> <span class="sh">'</span><span class="s">mean</span><span class="sh">'</span><span class="p">))</span>

<span class="n">ref</span> <span class="o">=</span> <span class="n">obs</span><span class="p">.</span><span class="n">loc</span><span class="p">[</span><span class="n">obs</span><span class="p">[</span><span class="sh">'</span><span class="s">tur</span><span class="sh">'</span><span class="p">]</span> <span class="o">==</span> <span class="sh">'</span><span class="s">kirsal</span><span class="sh">'</span><span class="p">,</span> <span class="sh">'</span><span class="s">t_air</span><span class="sh">'</span><span class="p">].</span><span class="nf">mean</span><span class="p">()</span>
<span class="k">if</span> <span class="n">pd</span><span class="p">.</span><span class="nf">isna</span><span class="p">(</span><span class="n">ref</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">Zaman penceresinde kırsal referans yok.</span><span class="sh">'</span><span class="p">)</span>

<span class="n">points</span> <span class="o">=</span> <span class="n">gpd</span><span class="p">.</span><span class="nc">GeoDataFrame</span><span class="p">(</span>
    <span class="n">obs</span><span class="p">,</span> <span class="n">geometry</span><span class="o">=</span><span class="n">gpd</span><span class="p">.</span><span class="nf">points_from_xy</span><span class="p">(</span><span class="n">obs</span><span class="p">.</span><span class="n">lon</span><span class="p">,</span> <span class="n">obs</span><span class="p">.</span><span class="n">lat</span><span class="p">),</span>
    <span class="n">crs</span><span class="o">=</span><span class="sh">'</span><span class="s">EPSG:4326</span><span class="sh">'</span>
<span class="p">).</span><span class="nf">to_crs</span><span class="p">(</span><span class="n">grid</span><span class="p">.</span><span class="n">crs</span><span class="p">)</span>

<span class="n">stats</span> <span class="o">=</span> <span class="nf">zonal_stats</span><span class="p">(</span><span class="n">grid</span><span class="p">,</span> <span class="sh">'</span><span class="s">lst_celsius.tif</span><span class="sh">'</span><span class="p">,</span>
                    <span class="n">stats</span><span class="o">=</span><span class="p">[</span><span class="sh">'</span><span class="s">mean</span><span class="sh">'</span><span class="p">],</span> <span class="n">nodata</span><span class="o">=-</span><span class="mi">9999</span><span class="p">)</span>
<span class="n">grid</span><span class="p">[</span><span class="sh">'</span><span class="s">lst_c</span><span class="sh">'</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="n">s</span><span class="p">[</span><span class="sh">'</span><span class="s">mean</span><span class="sh">'</span><span class="p">]</span> <span class="k">for</span> <span class="n">s</span> <span class="ow">in</span> <span class="n">stats</span><span class="p">]</span>
<span class="n">joined</span> <span class="o">=</span> <span class="n">gpd</span><span class="p">.</span><span class="nf">sjoin</span><span class="p">(</span><span class="n">points</span><span class="p">,</span> <span class="n">grid</span><span class="p">[[</span><span class="sh">'</span><span class="s">geometry</span><span class="sh">'</span><span class="p">]],</span>
                   <span class="n">how</span><span class="o">=</span><span class="sh">'</span><span class="s">inner</span><span class="sh">'</span><span class="p">,</span> <span class="n">predicate</span><span class="o">=</span><span class="sh">'</span><span class="s">within</span><span class="sh">'</span><span class="p">)</span>
<span class="n">means</span> <span class="o">=</span> <span class="n">joined</span><span class="p">.</span><span class="nf">groupby</span><span class="p">(</span><span class="sh">'</span><span class="s">index_right</span><span class="sh">'</span><span class="p">)[</span><span class="sh">'</span><span class="s">t_air</span><span class="sh">'</span><span class="p">].</span><span class="nf">mean</span><span class="p">()</span>
<span class="n">grid</span><span class="p">[</span><span class="sh">'</span><span class="s">delta_air</span><span class="sh">'</span><span class="p">]</span> <span class="o">=</span> <span class="n">grid</span><span class="p">.</span><span class="n">index</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="n">means</span><span class="p">)</span> <span class="o">-</span> <span class="n">ref</span>

<span class="n">fig</span><span class="p">,</span> <span class="n">axes</span> <span class="o">=</span> <span class="n">plt</span><span class="p">.</span><span class="nf">subplots</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">figsize</span><span class="o">=</span><span class="p">(</span><span class="mi">12</span><span class="p">,</span> <span class="mi">5</span><span class="p">))</span>
<span class="k">for</span> <span class="n">ax</span><span class="p">,</span> <span class="n">column</span> <span class="ow">in</span> <span class="nf">zip</span><span class="p">(</span><span class="n">axes</span><span class="p">,</span> <span class="p">[</span><span class="sh">'</span><span class="s">lst_c</span><span class="sh">'</span><span class="p">,</span> <span class="sh">'</span><span class="s">delta_air</span><span class="sh">'</span><span class="p">]):</span>
    <span class="n">grid</span><span class="p">.</span><span class="nf">plot</span><span class="p">(</span><span class="n">column</span><span class="o">=</span><span class="n">column</span><span class="p">,</span> <span class="n">ax</span><span class="o">=</span><span class="n">ax</span><span class="p">,</span> <span class="n">legend</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span>
              <span class="n">missing_kwds</span><span class="o">=</span><span class="p">{</span><span class="sh">'</span><span class="s">color</span><span class="sh">'</span><span class="p">:</span> <span class="sh">'</span><span class="s">lightgrey</span><span class="sh">'</span><span class="p">})</span>
    <span class="n">ax</span><span class="p">.</span><span class="nf">set_title</span><span class="p">(</span><span class="n">column</span> <span class="o">+</span> <span class="sh">'</span><span class="s"> (°C)</span><span class="sh">'</span><span class="p">)</span>
<span class="n">plt</span><span class="p">.</span><span class="nf">show</span><span class="p">()</span>
</code></pre></div></div>

<p>Önce her sensörün zaman ortalaması alınır; böylece sık kayıt yapan cihaz referansı gereksizce domine etmez. Mekânsal birleştirme sensörleri hücrelere atar. Sensör bulunmayan hücreler gri kalır: <strong>veri yokluğu, serinlik değildir</strong>.</p>

<h2 id="haritayı-doğru-yorumlamak">Haritayı doğru yorumlamak</h2>

<p>Sıcak yüzeylerle düşük NDVI birlikte görülüyorsa yeşil altyapı için aday bölgeler belirlenebilir. Yine de korelasyon, nedensellik kanıtı değildir. Rakım, yapı yoğunluğu ve kıyı etkisini ayrıca değerlendirin.</p>

<p>Tek görüntü yerine farklı günleri ve mümkünse gece ölçümlerini karşılaştırın. İnterpolasyon veya tahmin modeli kullanıyorsanız yakın noktaları rastgele bölmek yerine mekânsal doğrulama yapın; aksi hâlde başarı olduğundan yüksek görünebilir. Son haritaya tarih, birim, bulut boşlukları ve belirsizlik bilgisi ekleyin. Amaç yalnızca kırmızı bölgeler çizmek değil, nerede gölgeye ve serinlemeye ihtiyaç olduğunu güvenilir biçimde göstermektir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Proje" /><category term="veri analizi" /><category term="kentsel ısı adası" /><category term="python" /><category term="uydu verileri" /><category term="coğrafi bilgi sistemleri" /><category term="iklim" /><summary type="html"><![CDATA[Yazın aynı şehirde bir park serinletirken asfalt bir meydan neden fırın gibi hissettirir? Cevap yalnızca güneşte değil; yapı malzemelerinde, bitki örtüsünde ve hava dolaşımında saklıdır. Uydu görüntülerini yer sensörleriyle birleştirerek bu farkları ölçebilir, şehrin termal dedektifi olabiliriz. Ancak güzel bir harita çizmeden önce, hangi sıcaklığı ölçtüğümüzü anlamamız gerekir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/sehrin-sicak-noktalarini-58.png" /><media:content medium="image" url="https://program.sonsuz.us/img/sehrin-sicak-noktalarini-58.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">SLAM: Bir Araç Kaybolmadan Önce Haritasını Nasıl Çizer?</title><link href="https://program.sonsuz.us/posts/slam-bir-arac-kaybolmadan-once-haritasini-nasil-cizer/" rel="alternate" type="text/html" title="SLAM: Bir Araç Kaybolmadan Önce Haritasını Nasıl Çizer?" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/slam-bir-arac-kaybolmadan-once-haritasini-nasil-cizer</id><content type="html" xml:base="https://program.sonsuz.us/posts/slam-bir-arac-kaybolmadan-once-haritasini-nasil-cizer/"><![CDATA[<p>Gözlerinizi ilk kez açtığınız, daha önce hiç görmediğiniz bir binada olduğunuzu düşünün. Elinizde harita yok; üstelik nerede olduğunuzu da bilmiyorsunuz. Yürürken koridorları tanıyor, geçtiğiniz yerleri hatırlıyor ve zihninizde bir plan oluşturuyorsunuz. Otonom araçların bu çetrefilli işi sayılarla yapmasına <strong>SLAM</strong>, yani eşzamanlı konumlandırma ve haritalama denir.</p>

<p>``</p>

<h2 id="tavuk-mu-harita-mı">Tavuk mu, harita mı?</h2>

<p>SLAM’in temelinde karşılıklı bağımlılık vardır: Konumunuzu bulmak için haritaya, haritayı çizmek için konumunuza ihtiyaç duyarsınız. Çözüm, ikisini birlikte tahmin etmektir.</p>

<p>Araç; kamera, LiDAR, tekerlek enkoderi veya IMU gibi sensörlerden veri toplar. Durumu yalnızca koordinatlardan oluşmaz; yönelimi de içerir. Harita ise uygulamaya göre belirgin noktalar, doluluk hücreleri veya üç boyutlu nokta bulutu olabilir.</p>

<p>Başlangıç konumu genellikle referans kabul edilir. GPS gibi dış referanslar yoksa ortaya çıkan harita, Dünya üzerindeki mutlak konumdan ziyade başlangıca göre anlam taşır. Yani araç kendi mahallesini öğrenir; posta kodunu bilmek zorunda değildir.</p>

<h2 id="belirsizlik-sistemin-başrol-oyuncusu">Belirsizlik, sistemin başrol oyuncusu</h2>

<p>Sensörler kusursuz değildir. Tekerlek kayabilir, kamera bulanıklaşabilir, lazer camdan beklenmedik biçimde yansıyabilir. Bu yüzden SLAM tek bir kesin cevap yerine belirsizlik içeren tahminlerle çalışır.</p>

<p>Temel hedef şu olasılığı değerlendirmektir:</p>

\[p(x_{0:t}, m \mid z_{1:t}, u_{1:t})\]

<p>Burada $x_{0:t}$ aracın izlediği durum dizisi, $m$ harita, $z$ çevre gözlemleri, $u$ ise hareket bilgisidir. Başka bir ifadeyle: “Gördüklerim ve hareket ölçümlerim doğruysa hangi yol ve harita en tutarlı açıklamadır?”</p>

<p>EKF tabanlı yaklaşımlar durumları ve kovaryanslarını günceller. Graf tabanlı yaklaşımlar ise konumlar arasındaki ölçüm ilişkilerini optimize eder. Her iki yaklaşımda da hareket ve sensör modellerinin gerçekçi olması kritik önem taşır.</p>

<h2 id="ölçümden-haritaya-giden-yol">Ölçümden haritaya giden yol</h2>

<p>Tipik bir SLAM döngüsü şu adımları izler:</p>

<ol>
  <li><strong>Hareket tahmini:</strong> Odometri veya IMU, yeni konum için ilk tahmini üretir.</li>
  <li><strong>Özellik çıkarımı:</strong> Görüntü köşeleri ya da geometrik yüzeyler belirlenir.</li>
  <li><strong>Veri ilişkilendirme:</strong> Yeni gözlemlerin önceki hangi noktalara karşılık geldiği araştırılır.</li>
  <li><strong>Düzeltme:</strong> Sensör gözlemleriyle hareket tahmini uzlaştırılır.</li>
  <li><strong>Harita güncelleme:</strong> Yeni bölgeler eklenir, mevcut tahminler iyileştirilir.</li>
</ol>

<p>Sensör seçimi bu sürecin karakterini değiştirir:</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Güçlü tarafı</th>
      <th>Temel zorluğu</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>LiDAR SLAM</td>
      <td>Doğrudan mesafe ölçümü</td>
      <td>Maliyet ve geometrik benzerlik</td>
    </tr>
    <tr>
      <td>Görsel SLAM</td>
      <td>Zengin görüntü özellikleri</td>
      <td>Işık değişimi ve doku eksikliği</td>
    </tr>
    <tr>
      <td>Görsel-ataletsel SLAM</td>
      <td>Hızlı hareketlerde destek</td>
      <td>Kalibrasyon ve zaman eşleştirme</td>
    </tr>
  </tbody>
</table>

<p>Tek kameralı sistemlerde mutlak ölçek ayrıca belirsiz olabilir. Görüntüdeki hareket, ek bilgi olmadan gerçek dünyadaki metreyi kendiliğinden söylemez.</p>

<h2 id="döngü-kapatma-ben-burayı-görmüştüm">Döngü kapatma: “Ben burayı görmüştüm!”</h2>

<p>Küçük hareket hataları biriktikçe araç başlangıçtan giderek uzak bir konum hesaplayabilir. Buna <strong>sürüklenme</strong> denir. Daha önce ziyaret edilen bir yer tanındığında oluşan döngü kapatma kısıtı, geçmiş tahminlerin yeniden düzenlenmesini sağlar.</p>

<p>Graf yaklaşımında düğümler araç durumlarını, kenarlar ölçüm ilişkilerini temsil eder. Ancak yanlış bir eşleşme bütün haritayı bozabilir. Bu nedenle benzer görüntü bulmak yetmez; eşleşmenin geometrik olarak doğrulanması gerekir.</p>

<h2 id="python-ile-küçük-bir-optimizasyon-deneyi">Python ile küçük bir optimizasyon deneyi</h2>

<p>Aşağıdaki örnek NumPy ve SciPy kullanır. Yönelimleri sabit varsayarak yalnızca iki boyutlu konumları optimize eder; dolayısıyla tam bir SLAM sistemi değildir. Bütün yer değiştirme ölçümleri aynı koordinat çerçevesindedir.</p>

<p>Amaç fonksiyonu şöyledir:</p>

\[X^* = \arg\min_X \sum_{(i,j)} \frac{\\vert (x_j-x_i)-d_{ij}\\vert ^2}{\sigma_{ij}^2}\]

<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">least_squares</span>

<span class="c1"># Son kenar, yeniden tanınan yerden gelen kısıttır.
</span><span class="n">edges</span> <span class="o">=</span> <span class="p">[</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="p">[</span><span class="mf">1.1</span><span class="p">,</span> <span class="mf">0.1</span><span class="p">],</span> <span class="mf">0.15</span><span class="p">),</span>
    <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="p">[</span><span class="o">-</span><span class="mf">0.1</span><span class="p">,</span> <span class="mf">1.0</span><span class="p">],</span> <span class="mf">0.15</span><span class="p">),</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="p">[</span><span class="o">-</span><span class="mf">0.9</span><span class="p">,</span> <span class="o">-</span><span class="mf">0.1</span><span class="p">],</span> <span class="mf">0.15</span><span class="p">),</span>
    <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="p">[</span><span class="mf">0.0</span><span class="p">,</span> <span class="mf">1.0</span><span class="p">],</span> <span class="mf">0.05</span><span class="p">),</span>
<span class="p">]</span>

<span class="n">initial</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="mf">1.1</span><span class="p">,</span> <span class="mf">0.1</span><span class="p">],</span> <span class="p">[</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">1.1</span><span class="p">],</span> <span class="p">[</span><span class="mf">0.1</span><span class="p">,</span> <span class="mf">1.0</span><span class="p">]])</span>

<span class="k">def</span> <span class="nf">residual</span><span class="p">(</span><span class="n">flat</span><span class="p">):</span>
    <span class="c1"># İlk konumu sabitleyerek referans belirsizliğini gider.
</span>    <span class="n">positions</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="nf">vstack</span><span class="p">(([</span><span class="mf">0.0</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">],</span> <span class="n">flat</span><span class="p">.</span><span class="nf">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)))</span>
    <span class="n">errors</span> <span class="o">=</span> <span class="p">[]</span>
    <span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">j</span><span class="p">,</span> <span class="n">displacement</span><span class="p">,</span> <span class="n">sigma</span> <span class="ow">in</span> <span class="n">edges</span><span class="p">:</span>
        <span class="n">error</span> <span class="o">=</span> <span class="n">positions</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">-</span> <span class="n">positions</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">-</span> <span class="n">displacement</span>
        <span class="n">errors</span><span class="p">.</span><span class="nf">extend</span><span class="p">(</span><span class="n">error</span> <span class="o">/</span> <span class="n">sigma</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">np</span><span class="p">.</span><span class="nf">asarray</span><span class="p">(</span><span class="n">errors</span><span class="p">)</span>

<span class="n">result</span> <span class="o">=</span> <span class="nf">least_squares</span><span class="p">(</span><span class="n">residual</span><span class="p">,</span> <span class="n">initial</span><span class="p">.</span><span class="nf">ravel</span><span class="p">())</span>
<span class="nf">print</span><span class="p">(</span><span class="n">result</span><span class="p">.</span><span class="n">x</span><span class="p">.</span><span class="nf">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">))</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">residual</code>, ölçülen ve hesaplanan yer değiştirmeler arasındaki farkı döndürür. Standart sapması küçük ölçümler daha yüksek ağırlık kazanır. Optimizasyon, döngü kapatma bilgisini kullanarak hatayı konumlar arasında dağıtır. Gerçek sistemlerde yönelimler, koordinat dönüşümleri ve aykırı ölçümlere dayanıklı kayıp fonksiyonları da hesaba katılır.</p>

<h2 id="harita-çizmek-dünyayı-anlamak-değildir">Harita çizmek, dünyayı anlamak değildir</h2>

<p>SLAM geometrik tutarlılık sağlar; trafik kurallarını veya yayaların niyetlerini tek başına çözmez. Hareketli nesneler, birbirine benzeyen koridorlar ve sensör zamanlama hataları hâlâ ciddi sorunlardır. Başarılı sistemler bunları filtreleme, doğrulama ve sensör birleştirmeyle yönetir. Kısacası araç, sihirli bir pusulayla değil, sürekli sorguladığı ölçümlerle yolunu bulur.</p>

<p><img src="/img/slam-bir-arac-64.svg" alt="slam-bir-arac-64" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="slam" /><category term="robotik" /><category term="konumlandırma" /><category term="haritalama" /><category term="bilgisayarlı görü" /><category term="python" /><summary type="html"><![CDATA[Gözlerinizi ilk kez açtığınız, daha önce hiç görmediğiniz bir binada olduğunuzu düşünün. Elinizde harita yok; üstelik nerede olduğunuzu da bilmiyorsunuz. Yürürken koridorları tanıyor, geçtiğiniz yerleri hatırlıyor ve zihninizde bir plan oluşturuyorsunuz. Otonom araçların bu çetrefilli işi sayılarla yapmasına SLAM, yani eşzamanlı konumlandırma ve haritalama denir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/slam-bir-arac-64.png" /><media:content medium="image" url="https://program.sonsuz.us/img/slam-bir-arac-64.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Uydu Nerede? Kepler Denklemleriyle Yörünge Hesaplayan Bir Python Projesi</title><link href="https://program.sonsuz.us/posts/uydu-nerede-kepler-denklemleriyle-yorunge-hesaplayan-bir-python-projesi/" rel="alternate" type="text/html" title="Uydu Nerede? Kepler Denklemleriyle Yörünge Hesaplayan Bir Python Projesi" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/uydu-nerede-kepler-denklemleriyle-yorunge-hesaplayan-bir-python-projesi</id><content type="html" xml:base="https://program.sonsuz.us/posts/uydu-nerede-kepler-denklemleriyle-yorunge-hesaplayan-bir-python-projesi/"><![CDATA[<p><img src="/img/uydu-nerede-kepler-38.svg" alt="uydu-nerede-kepler-38" /></p>

<p>Bir uyduyu uzaya göndermek heyecanlıdır; fakat birkaç dakika sonra nerede olacağını bilmek de oldukça önemlidir! Haberleşme antenleri, gözlem planları ve uzay simülasyonları aynı soruya dayanır: Zaman ilerlediğinde cismin konumu nasıl değişir? Bu yazıda Kepler denklemini sayısal olarak çözüp eliptik bir yörüngenin konumunu Python ile hesaplayacağız.
``</p>

<h2 id="önce-fizik-i̇ki-cisimlik-evren">Önce fizik: İki cisimlik evren</h2>

<p>Modelimizde uydu ve merkezî gök cismi dışında kimse yok. Atmosfer, diğer gezegenler ve Dünya’nın basıklığı şimdilik sahne arkasında. Bu <strong>iki cisim yaklaşımında</strong>, bağlı bir yörünge elipstir ve merkezî cisim elipsin odaklarından birinde bulunur.</p>

<p>Yörüngeyi tanımlayan temel büyüklükler, yarı büyük eksen $a$ ve dışmerkezlik $e$ değerleridir. Dairesel yörüngede $e=0$, eliptik yörüngede $0&lt;e&lt;1$ olur. Kütleçekim parametresi $\mu=G(m_1+m_2)$ biçimindedir; küçük bir uydu için Dünya’nın değeri yaklaşık $398600.4418\;\mathrm{km^3/s^2}$ alınabilir.</p>

<p>Ortalama açısal hareket ve yörünge periyodu şöyle hesaplanır:</p>

\[n=\sqrt{\frac{\mu}{a^3}},\qquad T=\frac{2\pi}{n}\]

<p>Kilometre kullanıyorsanız bütün uzunlukları kilometre tutmalısınız. Birim karışıklığı, uydunuzu matematiksel olarak başka bir galaksiye göndermenin hızlı yoludur.</p>

<h2 id="zaman-neden-doğrudan-açı-değildir">Zaman neden doğrudan açı değildir?</h2>

<p>Kepler’in ikinci yasası nedeniyle uydu, merkezî cisme yakınken daha hızlı hareket eder. Dolayısıyla elips üzerinde sabit açısal hız varsayamayız. Bunun yerine zamanı, düzgün artan <strong>ortalama anomaliye</strong> dönüştürürüz:</p>

\[M(t)=M_0+n(t-t_0)\]

<p>Buradaki $M_0$, başlangıç anındaki ortalama anomalidir. Gerçek konuma geçmek için yardımcı bir açı olan <strong>eksantrik anomaliyi</strong>, yani $E$ değerini bulmalıyız:</p>

\[M=E-e\sin E\]

<p>Bu, meşhur Kepler denklemidir. Genel eliptik durumda $E$ için basit bir kapalı çözüm bulunmadığından sayısal yöntemlere başvururuz. Ortalama anomaliyi doğrudan geometrik açı sanmak, özellikle uzamış elipslerde belirgin konum hataları üretir.</p>

<h2 id="sayısal-yöntem-seçimi">Sayısal yöntem seçimi</h2>

<p>Çözmek istediğimiz fonksiyon $f(E)=E-e\sin E-M$, türevi ise $f’(E)=1-e\cos E$ olur. Eliptik yörüngelerde türev pozitiftir; böylece seçtiğimiz aralıkta kök tektir.</p>

<table>
  <thead>
    <tr>
      <th>Yöntem</th>
      <th>Avantajı</th>
      <th>Dikkat edilmesi gereken</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Newton–Raphson</td>
      <td>Kök yakınında çok hızlıdır</td>
      <td>Başlangıç tahminine duyarlıdır</td>
    </tr>
    <tr>
      <td>İkiye bölme</td>
      <td>Kökü çevreleyen aralıkta güvenilirdir</td>
      <td>Daha yavaş yakınsar</td>
    </tr>
    <tr>
      <td>Hibrit yöntem</td>
      <td>Hız ve güvenilirliği birleştirir</td>
      <td>Aralık takibi gerektirir</td>
    </tr>
  </tbody>
</table>

<p>Newton güncellemesi $E_{k+1}=E_k-f(E_k)/f’(E_k)$ şeklindedir. Aşağıdaki kod, Newton adımı güvenli aralığın dışına çıkarsa ikiye bölmeye geçer. Böylece yüksek dışmerkezliklerde de daha dayanıklı davranır.</p>

<h2 id="python-ile-konumu-hesaplayalım">Python ile konumu hesaplayalım</h2>

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


<span class="k">def</span> <span class="nf">kepler</span><span class="p">(</span><span class="n">M</span><span class="p">,</span> <span class="n">e</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-13</span><span class="p">):</span>
    <span class="n">M</span> <span class="o">=</span> <span class="p">(</span><span class="n">M</span> <span class="o">+</span> <span class="n">math</span><span class="p">.</span><span class="n">pi</span><span class="p">)</span> <span class="o">%</span> <span class="p">(</span><span class="mi">2</span> <span class="o">*</span> <span class="n">math</span><span class="p">.</span><span class="n">pi</span><span class="p">)</span> <span class="o">-</span> <span class="n">math</span><span class="p">.</span><span class="n">pi</span>
    <span class="n">lo</span><span class="p">,</span> <span class="n">hi</span> <span class="o">=</span> <span class="o">-</span><span class="n">math</span><span class="p">.</span><span class="n">pi</span><span class="p">,</span> <span class="n">math</span><span class="p">.</span><span class="n">pi</span>
    <span class="n">E</span> <span class="o">=</span> <span class="n">M</span> <span class="k">if</span> <span class="n">e</span> <span class="o">&lt;</span> <span class="mf">0.8</span> <span class="k">else</span> <span class="n">math</span><span class="p">.</span><span class="nf">copysign</span><span class="p">(</span><span class="n">math</span><span class="p">.</span><span class="n">pi</span><span class="p">,</span> <span class="n">M</span><span class="p">)</span>

    <span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="nf">range</span><span class="p">(</span><span class="mi">80</span><span class="p">):</span>
        <span class="n">f</span> <span class="o">=</span> <span class="n">E</span> <span class="o">-</span> <span class="n">e</span> <span class="o">*</span> <span class="n">math</span><span class="p">.</span><span class="nf">sin</span><span class="p">(</span><span class="n">E</span><span class="p">)</span> <span class="o">-</span> <span class="n">M</span>
        <span class="k">if</span> <span class="nf">abs</span><span class="p">(</span><span class="n">f</span><span class="p">)</span> <span class="o">&lt;</span> <span class="n">tol</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">E</span>

        <span class="k">if</span> <span class="n">f</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">:</span>
            <span class="n">hi</span> <span class="o">=</span> <span class="n">E</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="n">lo</span> <span class="o">=</span> <span class="n">E</span>

        <span class="n">candidate</span> <span class="o">=</span> <span class="n">E</span> <span class="o">-</span> <span class="n">f</span> <span class="o">/</span> <span class="p">(</span><span class="mi">1</span> <span class="o">-</span> <span class="n">e</span> <span class="o">*</span> <span class="n">math</span><span class="p">.</span><span class="nf">cos</span><span class="p">(</span><span class="n">E</span><span class="p">))</span>
        <span class="n">E</span> <span class="o">=</span> <span class="n">candidate</span> <span class="k">if</span> <span class="n">lo</span> <span class="o">&lt;</span> <span class="n">candidate</span> <span class="o">&lt;</span> <span class="n">hi</span> <span class="nf">else </span><span class="p">(</span><span class="n">lo</span> <span class="o">+</span> <span class="n">hi</span><span class="p">)</span> <span class="o">/</span> <span class="mi">2</span>

    <span class="k">raise</span> <span class="nc">RuntimeError</span><span class="p">(</span><span class="sh">'</span><span class="s">Kepler çözümü yakınsamadı</span><span class="sh">'</span><span class="p">)</span>


<span class="k">def</span> <span class="nf">position</span><span class="p">(</span><span class="n">dt</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">e</span><span class="p">,</span> <span class="n">M0</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span> <span class="n">mu</span><span class="o">=</span><span class="mf">398600.4418</span><span class="p">):</span>
    <span class="k">if</span> <span class="ow">not</span> <span class="p">(</span><span class="n">a</span> <span class="o">&gt;</span> <span class="mi">0</span> <span class="ow">and</span> <span class="n">mu</span> <span class="o">&gt;</span> <span class="mi">0</span> <span class="ow">and</span> <span class="mi">0</span> <span class="o">&lt;=</span> <span class="n">e</span> <span class="o">&lt;</span> <span class="mi">1</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">Eliptik yörünge parametrelerini kontrol edin</span><span class="sh">'</span><span class="p">)</span>

    <span class="n">n</span> <span class="o">=</span> <span class="n">math</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">(</span><span class="n">mu</span> <span class="o">/</span> <span class="n">a</span><span class="o">**</span><span class="mi">3</span><span class="p">)</span>
    <span class="n">E</span> <span class="o">=</span> <span class="nf">kepler</span><span class="p">(</span><span class="n">M0</span> <span class="o">+</span> <span class="n">n</span> <span class="o">*</span> <span class="n">dt</span><span class="p">,</span> <span class="n">e</span><span class="p">)</span>
    <span class="n">x</span> <span class="o">=</span> <span class="n">a</span> <span class="o">*</span> <span class="p">(</span><span class="n">math</span><span class="p">.</span><span class="nf">cos</span><span class="p">(</span><span class="n">E</span><span class="p">)</span> <span class="o">-</span> <span class="n">e</span><span class="p">)</span>
    <span class="n">y</span> <span class="o">=</span> <span class="n">a</span> <span class="o">*</span> <span class="n">math</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">(</span><span class="mi">1</span> <span class="o">-</span> <span class="n">e</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span> <span class="o">*</span> <span class="n">math</span><span class="p">.</span><span class="nf">sin</span><span class="p">(</span><span class="n">E</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span>


<span class="nf">print</span><span class="p">(</span><span class="nf">position</span><span class="p">(</span><span class="n">dt</span><span class="o">=</span><span class="mi">1200</span><span class="p">,</span> <span class="n">a</span><span class="o">=</span><span class="mi">7200</span><span class="p">,</span> <span class="n">e</span><span class="o">=</span><span class="mf">0.05</span><span class="p">))</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">dt</code>, başlangıçtan itibaren geçen saniyedir; <code class="language-plaintext highlighter-rouge">M0</code> radyan cinsindendir. Fonksiyon kilometre cinsinden iki koordinat döndürür. Açı normalizasyonu, çözümü tek tur üzerinde tutar. Döngü sınırıysa olası yakınsama sorunlarının sessizce gizlenmesini engeller.</p>

<p>Koordinatların başlangıcı elipsin merkezi değil, kütleçekim odağıdır. Pozitif x ekseni en yakın yaklaşım yönünü gösterir. Kullanılan dönüşüm doğrudan elips geometrisinden gelir:</p>

\[x=a(\cos E-e),\qquad y=a\sqrt{1-e^2}\sin E\]

<h2 id="sonuçları-nasıl-sınarız">Sonuçları nasıl sınarız?</h2>

<p>Önce $e=0$ seçin: Yarıçap sürekli $a$ olmalıdır. Ardından bir periyot sonraki konumun başlangıçla yaklaşık aynı olduğunu doğrulayın. $M_0=0$ için başlangıç uzaklığı $a(1-e)$, yarım periyot sonraki uzaklık $a(1+e)$ çıkmalıdır. Bunlar hem açı hesabını hem koordinat dönüşümünü sınayan küçük ama güçlü testlerdir.</p>

<p>Örnekteki yörüngenin periyodu yaklaşık 101 dakikadır. Çözüm toleransı denklem artığını sınırlar; özellikle $e$ bire yaklaşırken aynı artık, aynı konum doğruluğunu garanti etmez.</p>

<h2 id="gerçek-uzaya-bir-adım-daha">Gerçek uzaya bir adım daha</h2>

<p>Ürettiğimiz koordinatlar <strong>yörünge düzlemindedir</strong>, henüz Dünya merkezli üç boyutlu konum değildir. Bunun için eğim, çıkış düğümü boylamı ve periapsis argümanıyla dönme dönüşümleri uygulanmalıdır. Dünya’ya bağlı koordinatlar için ayrıca Dünya’nın dönüşü hesaba katılır.</p>

<p>Atmosferik sürükleme ve basıklık etkileri uzun vadede önem kazanır. Buradaki model eğitim ve basit simülasyonlar için harikadır; hassas operasyonel takipte daha kapsamlı modeller gerekir. İlk geliştirme olarak konumları zaman boyunca örnekleyip çizin: Kodunuz artık küçük bir yörünge laboratuvarı!</p>]]></content><author><name>Sonsuz Us</name></author><category term="Proje" /><category term="uydu" /><category term="yörünge" /><category term="kepler" /><category term="python" /><category term="sayısal yöntemler" /><category term="astrodinamik" /><summary type="html"><![CDATA[Bir uyduyu uzaya göndermek heyecanlıdır; fakat birkaç dakika sonra nerede olacağını bilmek de oldukça önemlidir! Haberleşme antenleri, gözlem planları ve uzay simülasyonları aynı soruya dayanır: Zaman ilerlediğinde cismin konumu nasıl değişir? Bu yazıda Kepler denklemini sayısal olarak çözüp eliptik bir yörüngenin konumunu Python ile hesaplayacağız.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/uydu-nerede-kepler-38.png" /><media:content medium="image" url="https://program.sonsuz.us/img/uydu-nerede-kepler-38.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Uzayda Sabit Kalmak: Uydu Yörüngelerinde PID Kontrolünün İncelikleri</title><link href="https://program.sonsuz.us/posts/uzayda-sabit-kalmak-uydu-yorungelerinde-pid-kontrolunun-incelikleri/" rel="alternate" type="text/html" title="Uzayda Sabit Kalmak: Uydu Yörüngelerinde PID Kontrolünün İncelikleri" /><published>2026-11-02T00:00:00+00:00</published><updated>2026-11-02T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/uzayda-sabit-kalmak-uydu-yorungelerinde-pid-kontrolunun-incelikleri</id><content type="html" xml:base="https://program.sonsuz.us/posts/uzayda-sabit-kalmak-uydu-yorungelerinde-pid-kontrolunun-incelikleri/"><![CDATA[<p>Bir uyduyu istediğimiz yerde tutmak, otomobilin hızını sabitlemeye benzer; fakat burada yol sürekli kıvrılır, yakıt sınırlıdır ve yanlış bir manevranın faturası oldukça kozmiktir. PID kontrolü, ölçülen hareketi hedef hareketle karşılaştırarak düzeltme üretir. Gelin bu tanıdık algoritmanın uzayda nasıl kullanıldığını, nerede işe yaradığını ve neden tek başına sihirli bir çözüm olmadığını inceleyelim.</p>

<p><img src="/img/uzayda-sabit-kalmak-69.svg" alt="uzayda-sabit-kalmak-69" /></p>

<p>``</p>

<h2 id="önce-kavramı-düzeltelim-hangi-konum-sabit">Önce kavramı düzeltelim: Hangi konum sabit?</h2>

<p>Uydu, Dünya çevresinde ilerlerken eylemsiz uzayda aynı noktada durmaz. <strong>Yörünge koruma</strong>, genellikle hedef yörüngeyi veya belirli bir referans hareketine göre konumu korumaktır. Jeostasyoner uydu bile Dünya ile birlikte döner; yalnızca yerdeki gözlemciye yaklaşık sabit görünür.</p>

<p>Bu yüzden kontrol hedefimiz çoğunlukla zamana bağlı bir referans konumudur: $r_{ref}(t)$. Konum hatası $e(t)=r_{ref}(t)-r(t)$ olarak tanımlanır. Ölçüm, kestirim, kontrol hesabı ve itici komutu birbirini izler. Yeni ölçüm geldiğinde döngü yeniden başlar: Uzayın kendine özgü bir “biraz sağa, şimdi biraz sola” dansı!</p>

<h2 id="yörünge-dinamiği-ve-pid-mantığı">Yörünge dinamiği ve PID mantığı</h2>

<p>Basitleştirilmiş eylemsiz koordinat modeli şöyledir:</p>

\[\ddot{r}=-\mu\frac{r}{\lVert r\rVert^3}+a_{bozucu}+a_{itki}\]

<p>Burada $\mu$ merkezî cismin kütleçekim parametresidir. Bozucu ivmeler; atmosferik sürükleme, Güneş ışınım basıncı veya başka gökcisimlerinin çekiminden kaynaklanabilir. İticiler ise denetleyicinin fiziksel dünyaya açılan kapısıdır.</p>

<p>PID, bu dinamikler dikkate alınarak uygulanacak düzeltme ivmesini hesaplamak için kullanılabilir:</p>

\[a_{PID}=K_p e+K_i\int e\,dt+K_d\dot{e}\]

<table>
  <thead>
    <tr>
      <th>Bileşen</th>
      <th>Baktığı bilgi</th>
      <th>Katkısı</th>
      <th>Fazlasının bedeli</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>P: Oransal</td>
      <td>Şimdiki hata</td>
      <td>Hedefe doğru düzeltme</td>
      <td>Salınım, sert komutlar</td>
    </tr>
    <tr>
      <td>I: İntegral</td>
      <td>Birikmiş hata</td>
      <td>Sürekli sapmayı giderme</td>
      <td>İntegral yığılması</td>
    </tr>
    <tr>
      <td>D: Türev</td>
      <td>Hatanın değişimi</td>
      <td>Hareketi sönümleme</td>
      <td>Gürültüyü büyütme</td>
    </tr>
  </tbody>
</table>

<p>P, hedefe uzaklığı önemser. I, küçük ama inatçı sapmaları unutmaz. D ise hedefe fazla hızlı yaklaşırken frene basar. Böylece denetleyici yalnızca “neredeyim?” değil, “nereye doğru gidiyorum?” sorusunu da sorar.</p>

<p>Ancak yörüngeye bağlı dönen koordinatlarda eksenler birbirini etkiler; Coriolis ve kütleçekim gradyanı terimleri ortaya çıkar. Üç bağımsız PID döngüsü, bu etkileşimler modellenmeden güvenilir kabul edilemez.</p>

<p>İdeal, ayrıştırılmış $\ddot{x}=u$ modeli için kapalı çevrim karakteristik polinomu $s^3+K_ds^2+K_ps+K_i$ olur. Pozitif kazançlarla kararlılık için ayrıca $K_dK_p&gt;K_i$ gerekir. Bu koşul gerçek uyduya doğrudan taşınmaz; gecikmeler ve modellenmeyen dinamikler tabloyu değiştirebilir.</p>

<h2 id="python-ile-sınırlı-itkiyi-hesaba-katmak">Python ile sınırlı itkiyi hesaba katmak</h2>

<p>Aşağıdaki tek eksenli örnek, nominal dinamiklerin model tabanlı telafi edildiği ideal bir düzeltme kanalını temsil eder. Çıktı ivmedir; doğrudan uçuş yazılımı değildir.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">class</span> <span class="nc">PID</span><span class="p">:</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="n">self</span><span class="p">,</span> <span class="n">kp</span><span class="p">,</span> <span class="n">ki</span><span class="p">,</span> <span class="n">kd</span><span class="p">,</span> <span class="n">limit</span><span class="p">):</span>
        <span class="n">self</span><span class="p">.</span><span class="n">kp</span><span class="p">,</span> <span class="n">self</span><span class="p">.</span><span class="n">ki</span><span class="p">,</span> <span class="n">self</span><span class="p">.</span><span class="n">kd</span> <span class="o">=</span> <span class="n">kp</span><span class="p">,</span> <span class="n">ki</span><span class="p">,</span> <span class="n">kd</span>
        <span class="n">self</span><span class="p">.</span><span class="n">limit</span> <span class="o">=</span> <span class="n">limit</span>
        <span class="n">self</span><span class="p">.</span><span class="n">integral</span> <span class="o">=</span> <span class="mf">0.0</span>

    <span class="k">def</span> <span class="nf">step</span><span class="p">(</span><span class="n">self</span><span class="p">,</span> <span class="n">ref</span><span class="p">,</span> <span class="n">pos</span><span class="p">,</span> <span class="n">ref_vel</span><span class="p">,</span> <span class="n">vel</span><span class="p">,</span> <span class="n">dt</span><span class="p">):</span>
        <span class="k">if</span> <span class="n">dt</span> <span class="o">&lt;=</span> <span class="mi">0</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">dt pozitif olmalı</span><span class="sh">"</span><span class="p">)</span>

        <span class="n">error</span> <span class="o">=</span> <span class="n">ref</span> <span class="o">-</span> <span class="n">pos</span>
        <span class="n">derivative</span> <span class="o">=</span> <span class="n">ref_vel</span> <span class="o">-</span> <span class="n">vel</span>
        <span class="n">candidate</span> <span class="o">=</span> <span class="n">self</span><span class="p">.</span><span class="n">integral</span> <span class="o">+</span> <span class="n">error</span> <span class="o">*</span> <span class="n">dt</span>

        <span class="k">def</span> <span class="nf">command</span><span class="p">(</span><span class="n">integral</span><span class="p">):</span>
            <span class="nf">return </span><span class="p">(</span><span class="n">self</span><span class="p">.</span><span class="n">kp</span> <span class="o">*</span> <span class="n">error</span> <span class="o">+</span> <span class="n">self</span><span class="p">.</span><span class="n">ki</span> <span class="o">*</span> <span class="n">integral</span>
                    <span class="o">+</span> <span class="n">self</span><span class="p">.</span><span class="n">kd</span> <span class="o">*</span> <span class="n">derivative</span><span class="p">)</span>

        <span class="n">raw</span> <span class="o">=</span> <span class="nf">command</span><span class="p">(</span><span class="n">candidate</span><span class="p">)</span>
        <span class="c1"># Doygunlukta hatayı büyüten integrasyonu durdur.
</span>        <span class="k">if</span> <span class="nf">abs</span><span class="p">(</span><span class="n">raw</span><span class="p">)</span> <span class="o">&lt;=</span> <span class="n">self</span><span class="p">.</span><span class="n">limit</span> <span class="ow">or</span> <span class="n">raw</span> <span class="o">*</span> <span class="n">error</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
            <span class="n">self</span><span class="p">.</span><span class="n">integral</span> <span class="o">=</span> <span class="n">candidate</span>

        <span class="n">raw</span> <span class="o">=</span> <span class="nf">command</span><span class="p">(</span><span class="n">self</span><span class="p">.</span><span class="n">integral</span><span class="p">)</span>
        <span class="k">return</span> <span class="nf">max</span><span class="p">(</span><span class="o">-</span><span class="n">self</span><span class="p">.</span><span class="n">limit</span><span class="p">,</span> <span class="nf">min</span><span class="p">(</span><span class="n">self</span><span class="p">.</span><span class="n">limit</span><span class="p">,</span> <span class="n">raw</span><span class="p">))</span>
</code></pre></div></div>

<p>Kod, türev terimini konum farklarını bölmek yerine hız hatasından hesaplar. Bu tercih, uygun hız kestirimiyle gürültü hassasiyetini azaltabilir. Koşullu integral güncellemesi <strong>anti-windup</strong> sağlar: İtici zaten sınırdayken integralin gereksiz yere büyümesini engeller. Gerçek sistemde hız ölçümleri de filtrelenmeli veya bir durum kestiricisinden alınmalıdır.</p>

<h2 id="simülasyondan-gerçek-uyduya">Simülasyondan gerçek uyduya</h2>

<p>Kazançları rastgele yükseltmek yerine önce P ve D ile sönümlü tepki oluşturun; ardından kalıcı sapma varsa I ekleyin. Her değişiklikte konum hatasını, hız hatasını ve toplam itki kullanımını izleyin. Daha hızlı toparlanma her zaman daha iyi değildir: Yakıt tüketimini artırabilir.</p>

<table>
  <thead>
    <tr>
      <th>Simülasyon testi</th>
      <th>Aranan sonuç</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Başlangıç konum hatası</td>
      <td>Kontrollü yaklaşma</td>
    </tr>
    <tr>
      <td>Sürekli küçük bozucu</td>
      <td>Azalan kalıcı sapma</td>
    </tr>
    <tr>
      <td>Sensör gürültüsü ve gecikme</td>
      <td>Kararlı, sakin komutlar</td>
    </tr>
    <tr>
      <td>İtici doygunluğu</td>
      <td>Sınırlı integral birikimi</td>
    </tr>
  </tbody>
</table>

<p>Son aşamada ivme isteği, $F=ma$ üzerinden kuvvete çevrilir; itici yönleri, minimum darbe süresi ve yönelim kısıtları dikkate alınır. Düşük itkiyle sürekli düzeltme ve kısa darbeli manevralar aynı uygulamayı gerektirmez.</p>

<p><strong>Özetle:</strong> PID iyi bir başlangıçtır; fakat başarılı yörünge koruma, doğru referans tanımı, dinamik model, güvenilir kestirim ve fiziksel sınırlarla birlikte tasarlanır. Uzayda mesele yalnızca hedefe dönmek değil, bunu yakıtı bitirmeden yapmaktır.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="pid" /><category term="kontrol teorisi" /><category term="uydu" /><category term="yörünge mekaniği" /><category term="python" /><category term="geri besleme" /><summary type="html"><![CDATA[Bir uyduyu istediğimiz yerde tutmak, otomobilin hızını sabitlemeye benzer; fakat burada yol sürekli kıvrılır, yakıt sınırlıdır ve yanlış bir manevranın faturası oldukça kozmiktir. PID kontrolü, ölçülen hareketi hedef hareketle karşılaştırarak düzeltme üretir. Gelin bu tanıdık algoritmanın uzayda nasıl kullanıldığını, nerede işe yaradığını ve neden tek başına sihirli bir çözüm olmadığını inceleyelim.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/uzayda-sabit-kalmak-69.png" /><media:content medium="image" url="https://program.sonsuz.us/img/uzayda-sabit-kalmak-69.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry></feed>