<?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-09-26T12:05:34+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">Contrastive Learning ve SimCLR: Etiketsiz Görsellerden Benzerlik Öğrenmek</title><link href="https://program.sonsuz.us/posts/contrastive-learning-ve-simclr-etiketsiz-gorsellerden-benzerlik-ogrenmek/" rel="alternate" type="text/html" title="Contrastive Learning ve SimCLR: Etiketsiz Görsellerden Benzerlik Öğrenmek" /><published>2026-09-26T00:00:00+00:00</published><updated>2026-09-26T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/contrastive-learning-ve-simclr-etiketsiz-gorsellerden-benzerlik-ogrenmek</id><content type="html" xml:base="https://program.sonsuz.us/posts/contrastive-learning-ve-simclr-etiketsiz-gorsellerden-benzerlik-ogrenmek/"><![CDATA[<p><img src="/img/contrastive-learning-ve-41.svg" alt="contrastive-learning-ve-41" /></p>

<p>Bir makineye binlerce kedi fotoğrafı gösterdiğinizi, fakat hiçbirine “kedi” etiketi koymadığınızı düşünün. Makine yine de kulak, tüy ve yüz şekli gibi ortak özellikleri keşfedebilir mi? Contrastive Learning, yani karşılaştırmalı öğrenme, tam olarak bunu hedefler: Benzer örnekleri temsil uzayında birbirine yaklaştırır, farklı örnekleri ise uzaklaştırır. SimCLR da bu fikri şaşırtıcı derecede sade bir eğitim düzenine dönüştüren popüler yöntemlerden biridir.
``</p>

<h2 id="temel-fikir-etiket-yerine-karşılaştırma">Temel fikir: Etiket yerine karşılaştırma</h2>

<p>Geleneksel denetimli öğrenmede model, bir görseli sınıf etiketiyle eşleştirir. Karşılaştırmalı öğrenmede ise “Bu nedir?” sorusundan önce “Bu iki görüntü aynı şeye mi ait?” sorusu sorulur. Böylece veri kendi eğitim sinyalini üretir.</p>

<p>Bir fotoğrafa rastgele kırpma, döndürme, renk değiştirme veya bulanıklaştırma uygulandığında iki farklı görünüm elde edilir. Bunlar <strong>pozitif çift</strong> kabul edilir. Aynı mini-batch içindeki diğer fotoğraflar ise genellikle <strong>negatif örneklerdir</strong>.</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Eğitim sinyali</th>
      <th>Amaç</th>
      <th>Etiket ihtiyacı</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Denetimli öğrenme</td>
      <td>İnsan tarafından verilen sınıf</td>
      <td>Doğru sınıfı tahmin etmek</td>
      <td>Yüksek</td>
    </tr>
    <tr>
      <td>Contrastive Learning</td>
      <td>Örnekler arasındaki ilişki</td>
      <td>Yararlı temsil öğrenmek</td>
      <td>Yok veya çok düşük</td>
    </tr>
    <tr>
      <td>SimCLR</td>
      <td>Artırılmış görüntü çiftleri</td>
      <td>Aynı görüntünün görünümlerini yaklaştırmak</td>
      <td>Yok</td>
    </tr>
  </tbody>
</table>

<p>Model, her görseli bir vektöre dönüştürür. İki temsil arasındaki benzerlik çoğunlukla kosinüs benzerliğiyle ölçülür:</p>

\[sim(a,b) = \frac{a \cdot b}{\Vert a\Vert \,\Vert b\Vert }\]

<p>Vektörler aynı yönü gösteriyorsa sonuç 1’e yaklaşır; birbirlerinden farklı yönlerdeyse küçülür. Yani sistem, pikselleri ezberlemek yerine anlamlı bir geometrik harita oluşturmaya çalışır.</p>

<h2 id="simclr-nasıl-çalışır">SimCLR nasıl çalışır?</h2>

<p>SimCLR boru hattı dört temel parçadan oluşur:</p>

<ol>
  <li>Batch içindeki her görüntüden iki rastgele görünüm üretilir.</li>
  <li>Görünümler, ResNet gibi bir encoder üzerinden geçirilerek $h$ temsilleri elde edilir.</li>
  <li>Küçük bir projection head, bu temsilleri $z$ uzayına taşır.</li>
  <li>Contrastive loss, pozitif çiftleri yaklaştırırken diğer örnekleri uzaklaştırır.</li>
</ol>

<p>SimCLR’da sık kullanılan NT-Xent kaybının sadeleştirilmiş biçimi şöyledir:</p>

\[L_{i,j} = -\log \frac{e^{sim(z_i,z_j)/t}}{\sum_{k \ne i} e^{sim(z_i,z_k)/t}}\]

<p>Buradaki $t$ sıcaklık parametresidir. Küçük sıcaklık, modelin benzerlik farklarına daha sert tepki vermesini sağlar. Pay kısmında pozitif eşleşme, paydada ise aday eşleşmeler bulunur. Kısacası modelden kalabalık içinde doğru “ikizi” bulması istenir.</p>

<h2 id="pytorch-ile-sade-bir-loss-örneği">PyTorch ile sade bir loss örneği</h2>

<p>Aşağıdaki kod, iki görünümün temsillerini normalize eder ve doğru çiftleri çapraz entropiyle öne çıkarır:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">torch</span>
<span class="kn">import</span> <span class="n">torch.nn.functional</span> <span class="k">as</span> <span class="n">F</span>

<span class="k">def</span> <span class="nf">contrastive_loss</span><span class="p">(</span><span class="n">z1</span><span class="p">,</span> <span class="n">z2</span><span class="p">,</span> <span class="n">temperature</span><span class="o">=</span><span class="mf">0.5</span><span class="p">):</span>
    <span class="n">z1</span> <span class="o">=</span> <span class="n">F</span><span class="p">.</span><span class="nf">normalize</span><span class="p">(</span><span class="n">z1</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
    <span class="n">z2</span> <span class="o">=</span> <span class="n">F</span><span class="p">.</span><span class="nf">normalize</span><span class="p">(</span><span class="n">z2</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>

    <span class="n">logits</span> <span class="o">=</span> <span class="n">z1</span> <span class="o">@</span> <span class="n">z2</span><span class="p">.</span><span class="n">T</span> <span class="o">/</span> <span class="n">temperature</span>
    <span class="n">labels</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="nf">arange</span><span class="p">(</span><span class="n">z1</span><span class="p">.</span><span class="nf">size</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span> <span class="n">device</span><span class="o">=</span><span class="n">z1</span><span class="p">.</span><span class="n">device</span><span class="p">)</span>

    <span class="n">loss_1</span> <span class="o">=</span> <span class="n">F</span><span class="p">.</span><span class="nf">cross_entropy</span><span class="p">(</span><span class="n">logits</span><span class="p">,</span> <span class="n">labels</span><span class="p">)</span>
    <span class="n">loss_2</span> <span class="o">=</span> <span class="n">F</span><span class="p">.</span><span class="nf">cross_entropy</span><span class="p">(</span><span class="n">logits</span><span class="p">.</span><span class="n">T</span><span class="p">,</span> <span class="n">labels</span><span class="p">)</span>
    <span class="nf">return </span><span class="p">(</span><span class="n">loss_1</span> <span class="o">+</span> <span class="n">loss_2</span><span class="p">)</span> <span class="o">/</span> <span class="mi">2</span>
</code></pre></div></div>

<p>Matrisin köşegenindeki elemanlar doğru pozitif çiftlerdir. Fonksiyon iki yönü de hesaplayarak birinci görünümden ikinciyi ve ikinci görünümden birinciyi bulmayı öğretir. Gerçek SimCLR uygulamalarında aynı görünümün kendisiyle karşılaştırılması maskelenir ve batch içindeki tüm $2N$ temsil değerlendirilir.</p>

<h2 id="neden-veri-artırma-bu-kadar-önemli">Neden veri artırma bu kadar önemli?</h2>

<p>Model yalnızca kırpılmış iki görüntüyü eşleştirirse konuma, yalnızca renk değişimini görürse renge bağımlı olabilir. Güçlü ve çeşitli dönüşümler, modele “Renk değişse de nesne aynı kalabilir” fikrini öğretir.</p>

<table>
  <thead>
    <tr>
      <th>Dönüşüm</th>
      <th>Öğretilen dayanıklılık</th>
      <th>Olası risk</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Rastgele kırpma</td>
      <td>Konum ve ölçek değişimi</td>
      <td>Ana nesneyi kaybetmek</td>
    </tr>
    <tr>
      <td>Renk bozma</td>
      <td>Işık ve ton değişimi</td>
      <td>Sınıfa ait renk bilgisini silmek</td>
    </tr>
    <tr>
      <td>Bulanıklaştırma</td>
      <td>Doku değişimi</td>
      <td>İnce ayrıntıları yok etmek</td>
    </tr>
  </tbody>
</table>

<p>Eğitim tamamlandığında projection head genellikle atılır; encoder’dan çıkan temsiller sınıflandırma, benzer görsel arama veya kümeleme gibi görevlerde kullanılır. SimCLR’ın sihri aslında sihir değildir: İyi veri artırma, yeterince büyük batch ve doğru kayıp fonksiyonunun uyumlu çalışmasıdır. Etiketsiz bir fotoğraf arşivi böylece sessiz bir veri yığınından, kendi benzerlik dilini öğreten güçlü bir öğretmene dönüşür.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="contrastive learning" /><category term="simclr" /><category term="derin öğrenme" /><category term="bilgisayarlı görü" /><category term="yapay zeka" /><category term="self-supervised learning" /><summary type="html"><![CDATA[Bir makineye binlerce kedi fotoğrafı gösterdiğinizi, fakat hiçbirine “kedi” etiketi koymadığınızı düşünün. Makine yine de kulak, tüy ve yüz şekli gibi ortak özellikleri keşfedebilir mi? Contrastive Learning, yani karşılaştırmalı öğrenme, tam olarak bunu hedefler: Benzer örnekleri temsil uzayında birbirine yaklaştırır, farklı örnekleri ise uzaklaştırır. SimCLR da bu fikri şaşırtıcı derecede sade bir eğitim düzenine dönüştüren popüler yöntemlerden biridir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/contrastive-learning-ve-41.png" /><media:content medium="image" url="https://program.sonsuz.us/img/contrastive-learning-ve-41.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">DDPM: Gürültüden Şahesere Giden Matematiksel Yolculuk</title><link href="https://program.sonsuz.us/posts/ddpm-gurultuden-sahesere-giden-matematiksel-yolculuk/" rel="alternate" type="text/html" title="DDPM: Gürültüden Şahesere Giden Matematiksel Yolculuk" /><published>2026-09-26T00:00:00+00:00</published><updated>2026-09-26T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/ddpm-gurultuden-sahesere-giden-matematiksel-yolculuk</id><content type="html" xml:base="https://program.sonsuz.us/posts/ddpm-gurultuden-sahesere-giden-matematiksel-yolculuk/"><![CDATA[<p>Bir televizyonun çekmediği kanaldaki karıncalanmayı düşünün. Şimdi bu rastgele piksellerin yavaşça bir kediye, uzay gemisine veya Van Gogh esintili bir manzaraya dönüştüğünü hayal edin. Denoising Diffusion Probabilistic Models, yani DDPM, tam olarak bunu yapar: Veriyi kontrollü biçimde gürültüye dönüştürmeyi öğrenir ve ardından zamanı tersine sararak gürültüden yeni görüntüler üretir.
``</p>
<h2 id="termodinamikten-gelen-temel-fikir">Termodinamikten gelen temel fikir</h2>

<p>Difüzyon, fiziksel sistemlerin zamanla daha düzensiz hâle gelmesini anlatır. Bir bardak suya damlatılan mürekkebin kendiliğinden yayılması bunun klasik örneğidir. Başlangıçtaki düzen kaybolurken sistemin entropisi artar. DDPM de gerçek bir görüntüye küçük miktarlarda Gauss gürültüsü ekleyerek benzer bir süreç kurar.</p>

<p>Model iki ayrı süreçten oluşur:</p>

<table>
  <thead>
    <tr>
      <th>Süreç</th>
      <th>Yön</th>
      <th>Amaç</th>
      <th>Öğreniliyor mu?</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>İleri difüzyon</td>
      <td>Görüntüden gürültüye</td>
      <td>Veriyi aşamalı olarak bozmak</td>
      <td>Hayır</td>
    </tr>
    <tr>
      <td>Ters difüzyon</td>
      <td>Gürültüden görüntüye</td>
      <td>Gürültüyü aşamalı olarak temizlemek</td>
      <td>Evet</td>
    </tr>
  </tbody>
</table>

<p><img src="/img/ddpm-gurultuden-sahesere-67.svg" alt="ddpm-gurultuden-sahesere-67" /></p>

<p>İleri süreç mürekkebin suya yayılması kadar kolaydır. Asıl marifet, yayılmış mürekkebi yeniden tek bir damlada toplamak gibi davranan ters süreçtedir.</p>

<h2 id="i̇leri-difüzyon-görüntüyü-kontrollü-bozmak">İleri difüzyon: Görüntüyü kontrollü bozmak</h2>

<p>Temiz görüntüyü $x_0$ ile gösterelim. Her $t$ adımında görüntüye, miktarı bir varyans çizelgesiyle belirlenen gürültü eklenir:</p>

\[q(x_t\mid x_{t-1})=\mathcal{N}(x_t;\sqrt{1-\beta_t}x_{t-1},\beta_tI)\]

<p>Buradaki $\beta_t$, ilgili adımdaki gürültü miktarıdır. Küçük değerler görüntünün yavaşça bozulmasını sağlar. Güzel tarafı, yüzlerce adımı sırayla çalıştırmadan herhangi bir $t$ anına doğrudan sıçrayabilmemizdir:</p>

\[x_t=\sqrt{\bar{\alpha}_t}x_0+\sqrt{1-\bar{\alpha}_t}\epsilon\]

<p>Burada $\alpha_t=1-\beta_t$, $\bar{\alpha}<em>t=\prod</em>{s=1}^{t}\alpha_s$ ve $\epsilon\sim\mathcal{N}(0,I)$ olur. İlk terim korunmuş görüntüyü, ikinci terim eklenen rastgeleliği temsil eder.</p>

<table>
  <thead>
    <tr>
      <th>Zaman</th>
      <th style="text-align: right">Görüntü bilgisi</th>
      <th style="text-align: right">Gürültü</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>$t=0$</td>
      <td style="text-align: right">Çok yüksek</td>
      <td style="text-align: right">Yok</td>
    </tr>
    <tr>
      <td>Orta adımlar</td>
      <td style="text-align: right">Kısmen görünür</td>
      <td style="text-align: right">Orta</td>
    </tr>
    <tr>
      <td>$t=T$</td>
      <td style="text-align: right">Neredeyse yok</td>
      <td style="text-align: right">Çok yüksek</td>
    </tr>
  </tbody>
</table>

<h2 id="ters-süreç-gürültüyü-tahmin-etmek">Ters süreç: Gürültüyü tahmin etmek</h2>

<p>Model, $x_t$ görüntüsünü ve zaman adımı $t$ değerini alarak eklenmiş gürültüyü tahmin eder. Genellikle omurgada, farklı çözünürlüklerde ayrıntı yakalayabilen bir <strong>U-Net</strong> bulunur. Sinir ağı $\epsilon_\theta(x_t,t)$ tahminini üretir; bu tahmin kullanılarak biraz daha temiz olan $x_{t-1}$ hesaplanır.</p>

<p>Eğitim kaybı şaşırtıcı derecede sadedir:</p>

\[L=\mathbb{E}_{x_0,t,\epsilon}\left[\lVert\epsilon-\epsilon_\theta(x_t,t)\rVert^2\right]\]

<p>Başka bir deyişle model, gerçek gürültü ile tahmin ettiği gürültü arasındaki karesel farkı küçültür. Görüntünün kendisini ezberlemek yerine her bozulma seviyesinde hangi parçanın rastgele olduğunu öğrenir.</p>

<p>Aşağıdaki PyTorch benzeri kod, tek bir eğitim adımının özünü gösterir:</p>

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

<span class="c1"># Her örnek için rastgele bir difüzyon zamanı seçilir.
</span><span class="n">t</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="nf">randint</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">total_steps</span><span class="p">,</span> <span class="p">(</span><span class="n">images</span><span class="p">.</span><span class="nf">size</span><span class="p">(</span><span class="mi">0</span><span class="p">),),</span> <span class="n">device</span><span class="o">=</span><span class="n">images</span><span class="p">.</span><span class="n">device</span><span class="p">)</span>
<span class="n">noise</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="nf">randn_like</span><span class="p">(</span><span class="n">images</span><span class="p">)</span>

<span class="c1"># Kapalı formül sayesinde görüntü doğrudan x_t seviyesine taşınır.
</span><span class="n">noisy</span> <span class="o">=</span> <span class="n">sqrt_alpha_bar</span><span class="p">[</span><span class="n">t</span><span class="p">]</span> <span class="o">*</span> <span class="n">images</span>
<span class="n">noisy</span> <span class="o">+=</span> <span class="n">sqrt_one_minus_alpha_bar</span><span class="p">[</span><span class="n">t</span><span class="p">]</span> <span class="o">*</span> <span class="n">noise</span>

<span class="c1"># U-Net eklenen gürültüyü tahmin eder.
</span><span class="n">predicted_noise</span> <span class="o">=</span> <span class="nf">model</span><span class="p">(</span><span class="n">noisy</span><span class="p">,</span> <span class="n">t</span><span class="p">)</span>
<span class="n">loss</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="nf">mean</span><span class="p">((</span><span class="n">noise</span> <span class="o">-</span> <span class="n">predicted_noise</span><span class="p">)</span> <span class="o">**</span> <span class="mi">2</span><span class="p">)</span>

<span class="n">optimizer</span><span class="p">.</span><span class="nf">zero_grad</span><span class="p">()</span>
<span class="n">loss</span><span class="p">.</span><span class="nf">backward</span><span class="p">()</span>
<span class="n">optimizer</span><span class="p">.</span><span class="nf">step</span><span class="p">()</span>
</code></pre></div></div>

<h2 id="üretim-neden-yavaş-ama-etkileyici">Üretim neden yavaş ama etkileyici?</h2>

<p>Üretim sırasında süreç saf $x_T$ gürültüsüyle başlar. Model, yüzlerce veya binlerce küçük temizleme adımı uygular. GAN modelleri çoğunlukla tek geçişte sonuç üretirken DDPM daha sabırlıdır; adeta bir heykeltıraş gibi her adımda rastgeleliği biraz daha yontar.</p>

<p>Bu aşamalı yaklaşım yüksek çeşitlilik, kararlı eğitim ve güçlü görüntü kalitesi sağlar. Dezavantajı hesaplama maliyetidir. DDIM, latent diffusion ve gelişmiş örnekleyiciler adım sayısını azaltarak bu sorunu hafifletir. Sonuçta görünen sihir, aslında olasılık teorisi, termodinamik sezgi ve dikkatle eğitilmiş bir gürültü tahmincisinin zarif iş birliğidir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="ddpm" /><category term="difüzyon" /><category term="yapay zeka" /><category term="derin öğrenme" /><category term="görüntü üretimi" /><category term="pytorch" /><summary type="html"><![CDATA[Bir televizyonun çekmediği kanaldaki karıncalanmayı düşünün. Şimdi bu rastgele piksellerin yavaşça bir kediye, uzay gemisine veya Van Gogh esintili bir manzaraya dönüştüğünü hayal edin. Denoising Diffusion Probabilistic Models, yani DDPM, tam olarak bunu yapar: Veriyi kontrollü biçimde gürültüye dönüştürmeyi öğrenir ve ardından zamanı tersine sararak gürültüden yeni görüntüler üretir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/ddpm-gurultuden-sahesere-67.png" /><media:content medium="image" url="https://program.sonsuz.us/img/ddpm-gurultuden-sahesere-67.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Federated Learning ve Diferansiyel Gizlilik: Veri Cihazdan Çıkmadan Model Eğitmek</title><link href="https://program.sonsuz.us/posts/federated-learning-ve-diferansiyel-gizlilik-veri-cihazdan-cikmadan-model-egitmek/" rel="alternate" type="text/html" title="Federated Learning ve Diferansiyel Gizlilik: Veri Cihazdan Çıkmadan Model Eğitmek" /><published>2026-09-26T00:00:00+00:00</published><updated>2026-09-26T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/federated-learning-ve-diferansiyel-gizlilik-veri-cihazdan-cikmadan-model-egitmek</id><content type="html" xml:base="https://program.sonsuz.us/posts/federated-learning-ve-diferansiyel-gizlilik-veri-cihazdan-cikmadan-model-egitmek/"><![CDATA[<p><img src="/img/federated-learning-ve-24.svg" alt="federated-learning-ve-24" /></p>

<p>Telefonunuzun yazdığınız kelimeleri tahmin etmeyi öğrendiğini, ancak mesajlarınızın hiçbir zaman merkezi bir sunucuya gönderilmediğini düşünün. Federated Learning, yani federe öğrenme, tam olarak bu fikri hayata geçirir: Veriyi modele taşımak yerine modeli veriye götürür. Diferansiyel gizlilik ise paylaşılan model güncellemelerinden kişisel bilgilerin çıkarılmasını matematiksel olarak zorlaştırır.</p>

<p>``</p>

<h2 id="federe-öğrenme-nasıl-çalışır">Federe öğrenme nasıl çalışır?</h2>

<p>Klasik makine öğrenmesinde kullanıcı verileri merkezi bir veri tabanında toplanır ve model burada eğitilir. Federe öğrenmede sunucu, mevcut global modeli seçilen cihazlara yollar. Her cihaz modeli kendi yerel verisiyle birkaç tur eğitir ve yalnızca hesapladığı ağırlık güncellemesini sunucuya gönderir.</p>

<p>Sunucu, bu güncellemeleri genellikle <strong>Federated Averaging (FedAvg)</strong> algoritmasıyla birleştirir:</p>

\[w_{t+1} = \sum_{k=1}^{K} \frac{n_k}{N} w_{t+1}^{(k)}\]

<p>Burada $w_{t+1}^{(k)}$, $k$ numaralı cihazın güncellediği ağırlıkları; $n_k$, cihazdaki örnek sayısını; $N$ ise katılan cihazlardaki toplam örnek sayısını temsil eder. Daha fazla veriye sahip cihazın katkısı doğal olarak daha yüksek olur.</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Veri nerede?</th>
      <th>Sunucuya giden</th>
      <th>Temel risk</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Merkezi eğitim</td>
      <td>Sunucuda</td>
      <td>Ham kullanıcı verisi</td>
      <td>Veri tabanı sızıntısı</td>
    </tr>
    <tr>
      <td>Federe öğrenme</td>
      <td>Kullanıcı cihazında</td>
      <td>Model güncellemesi</td>
      <td>Güncellemeden bilgi çıkarımı</td>
    </tr>
    <tr>
      <td>Federe öğrenme + DP</td>
      <td>Kullanıcı cihazında</td>
      <td>Gürültülü güncelleme</td>
      <td>Kontrollü doğruluk kaybı</td>
    </tr>
  </tbody>
</table>

<h2 id="güncellemeler-gerçekten-güvenli-mi">Güncellemeler gerçekten güvenli mi?</h2>

<p>Ham verinin gönderilmemesi tek başına kusursuz gizlilik sağlamaz. Saldırganlar gradyanlardan eğitim örneklerini yaklaşık olarak yeniden oluşturabilir veya belirli bir kullanıcının eğitime katılıp katılmadığını tahmin edebilir. İşte diferansiyel gizlilik, kısaca <strong>DP</strong>, burada devreye girer.</p>

<p>Bir mekanizma $M$, komşu iki veri kümesi $D$ ve $D’$ için şu koşulu sağlıyorsa $(\varepsilon, \delta)$-diferansiyel gizlidir:</p>

\[P[M(D) \in S] \leq e^{\varepsilon}P[M(D') \in S] + \delta\]

<p>Komşu veri kümeleri yalnızca bir kullanıcının eklenmesi veya çıkarılması bakımından farklıdır. Küçük $\varepsilon$ daha güçlü gizlilik, fakat çoğunlukla daha fazla gürültü ve daha düşük model doğruluğu demektir. $\delta$ ise ideal garantinin çok küçük bir olasılıkla aşılmasına izin verir.</p>

<h2 id="kırpma-ve-gürültü-ekleme">Kırpma ve gürültü ekleme</h2>

<p>Cihaz güncellemeleri önce norm sınırı $C$ ile kırpılır. Böylece tek bir kullanıcının global modele yapabileceği maksimum etki kontrol edilir:</p>

\[\bar{g}_k = g_k \cdot \min\left(1, \frac{C}{\lVert g_k \rVert_2}\right)\]

<p>Ardından toplama Gaussian gürültüsü eklenir. Aşağıdaki basitleştirilmiş Python kodu bu iki adımı gösterir:</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">privatize_update</span><span class="p">(</span><span class="n">update</span><span class="p">,</span> <span class="n">clip_norm</span><span class="o">=</span><span class="mf">1.0</span><span class="p">,</span> <span class="n">noise_scale</span><span class="o">=</span><span class="mf">0.2</span><span class="p">):</span>
    <span class="c1"># Güncellemenin etkisini belirlenen üst sınırda tutar.
</span>    <span class="n">norm</span> <span class="o">=</span> <span class="n">np</span><span class="p">.</span><span class="n">linalg</span><span class="p">.</span><span class="nf">norm</span><span class="p">(</span><span class="n">update</span><span class="p">)</span>
    <span class="n">clipped</span> <span class="o">=</span> <span class="n">update</span> <span class="o">*</span> <span class="nf">min</span><span class="p">(</span><span class="mf">1.0</span><span class="p">,</span> <span class="n">clip_norm</span> <span class="o">/</span> <span class="p">(</span><span class="n">norm</span> <span class="o">+</span> <span class="mf">1e-12</span><span class="p">))</span>

    <span class="c1"># Bireysel katkının ayırt edilmesini zorlaştırır.
</span>    <span class="n">noise</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">normal</span><span class="p">(</span>
        <span class="n">loc</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span>
        <span class="n">scale</span><span class="o">=</span><span class="n">noise_scale</span> <span class="o">*</span> <span class="n">clip_norm</span><span class="p">,</span>
        <span class="n">size</span><span class="o">=</span><span class="n">update</span><span class="p">.</span><span class="n">shape</span>
    <span class="p">)</span>
    <span class="k">return</span> <span class="n">clipped</span> <span class="o">+</span> <span class="n">noise</span>
</code></pre></div></div>

<p>Gerçek sistemlerde gürültü her cihazda veya güvenli toplama sonrasında sunucuda uygulanabilir. <strong>Secure Aggregation</strong> kullanıldığında sunucu tek tek güncellemeleri göremez; yalnızca toplam sonucu elde eder. Bu teknik DP’nin alternatifi değil, güçlü bir tamamlayıcısıdır.</p>

<h2 id="milyonlarca-cihaz-neden-zorlu">Milyonlarca cihaz neden zorlu?</h2>

<p>Cihazların işlem gücü, bağlantı kalitesi ve veri dağılımları farklıdır. Bir telefonda gece çekilmiş fotoğraflar, diğerinde gündüz görüntüleri bulunabilir; yani veriler çoğunlukla bağımsız ve özdeş dağılımlı değildir. Ayrıca her turda cihazların yalnızca küçük bir bölümü çevrim içidir.</p>

<table>
  <thead>
    <tr>
      <th>Karar</th>
      <th>Avantaj</th>
      <th>Bedel</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Daha küçük $\varepsilon$</td>
      <td>Güçlü gizlilik</td>
      <td>Daha fazla doğruluk kaybı</td>
    </tr>
    <tr>
      <td>Büyük kırpma sınırı</td>
      <td>Faydalı sinyal korunur</td>
      <td>Kullanıcı etkisi artar</td>
    </tr>
    <tr>
      <td>Fazla eğitim turu</td>
      <td>Model gelişebilir</td>
      <td>Gizlilik bütçesi tüketilir</td>
    </tr>
    <tr>
      <td>Güvenli toplama</td>
      <td>Güncellemeleri saklar</td>
      <td>İletişim maliyeti yaratır</td>
    </tr>
  </tbody>
</table>

<p>Sonuç olarak federe öğrenme veriyi cihazda tutar, diferansiyel gizlilik ise modelin veriyi istemeden ezberlemesini sınırlar. İkisi güvenli toplama, şifreli iletişim ve düzenli gizlilik muhasebesiyle birleştiğinde milyonlarca kullanıcıdan öğrenen; ancak tek bir kullanıcı hakkında mümkün olduğunca az şey söyleyen dev modeller kurulabilir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="federated learning" /><category term="diferansiyel gizlilik" /><category term="makine öğrenmesi" /><category term="yapay zeka" /><category term="veri güvenliği" /><category term="python" /><summary type="html"><![CDATA[Telefonunuzun yazdığınız kelimeleri tahmin etmeyi öğrendiğini, ancak mesajlarınızın hiçbir zaman merkezi bir sunucuya gönderilmediğini düşünün. Federated Learning, yani federe öğrenme, tam olarak bu fikri hayata geçirir: Veriyi modele taşımak yerine modeli veriye götürür. Diferansiyel gizlilik ise paylaşılan model güncellemelerinden kişisel bilgilerin çıkarılmasını matematiksel olarak zorlaştırır.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/federated-learning-ve-24.png" /><media:content medium="image" url="https://program.sonsuz.us/img/federated-learning-ve-24.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Karar Ağaçlarında Gini Impurity ve Entropy: Bölünme Kriterlerinin Matematiği</title><link href="https://program.sonsuz.us/posts/karar-agaclarinda-gini-impurity-ve-entropy-bolunme-kriterlerinin-matematigi/" rel="alternate" type="text/html" title="Karar Ağaçlarında Gini Impurity ve Entropy: Bölünme Kriterlerinin Matematiği" /><published>2026-09-26T00:00:00+00:00</published><updated>2026-09-26T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/karar-agaclarinda-gini-impurity-ve-entropy-bolunme-kriterlerinin-matematigi</id><content type="html" xml:base="https://program.sonsuz.us/posts/karar-agaclarinda-gini-impurity-ve-entropy-bolunme-kriterlerinin-matematigi/"><![CDATA[<p>Bir karar ağacı, verileri dallara ayırırken sürekli aynı soruyu sorar: “Hangi bölünme, sınıfları birbirinden en iyi şekilde ayırır?” Bu soruyu yalnızca sezgilerle cevaplamak yerine düğümlerin ne kadar karışık olduğunu ölçeriz. Sınıflandırma ağaçlarında bu amaçla en sık kullanılan iki ölçüt <strong>Gini Impurity</strong> ve <strong>Entropy</strong>’dir. İkisi de aynı hedefe koşar; ancak hedefe giderken kullandıkları matematiksel rota biraz farklıdır.</p>

<p>``</p>

<h2 id="saflık-ve-belirsizlik-ne-anlama-gelir">Saflık ve belirsizlik ne anlama gelir?</h2>

<p>Bir düğümdeki örneklerin tamamı aynı sınıfa aitse düğüm saftır. Örneğin kutuda yalnızca elmalar bulunuyorsa belirsizlik yoktur. Kutuda eşit sayıda elma ve armut varsa hangi meyveyi çekeceğimizi tahmin etmek daha zordur.</p>

<p>İki sınıflı bir problemde pozitif sınıfın oranı $p$, negatif sınıfın oranı $1-p$ olsun. Hem Gini hem de Entropy, $p=0$ veya $p=1$ olduğunda sıfır değerini alır. En yüksek belirsizlik ise sınıflar dengeliyken, yani $p=0.5$ civarında ortaya çıkar.</p>

<h2 id="gini-impurity-matematiği">Gini Impurity matematiği</h2>

<p>Gini Impurity, rastgele seçilen bir örneğin düğümdeki sınıf dağılımına göre rastgele etiketlenmesi durumunda yanlış sınıflandırılma olasılığını temsil eder:</p>

\[Gini = 1 - \sum_{i=1}^{K} p_i^2\]

<p>Burada $K$ sınıf sayısını, $p_i$ ise $i$ sınıfının düğümdeki oranını gösterir. Yüzde 50 kedi ve yüzde 50 köpek bulunan bir düğüm için:</p>

\[Gini = 1-(0.5^2+0.5^2)=0.5\]

<p>Dağılım yüzde 90 kedi ve yüzde 10 köpek olduğunda sonuç $0.18$ olur. Değerin küçülmesi, düğümün daha saf hâle geldiğini gösterir.</p>

<h2 id="entropy-ve-bilgi-teorisi">Entropy ve bilgi teorisi</h2>

<p>Entropy, bilgi teorisinden gelir ve bir dağılımdaki şaşkınlığı ya da belirsizliği ölçer:</p>

\[Entropy = -\sum_{i=1}^{K} p_i\log_2(p_i)\]

<p>Eşit dağılımlı iki sınıfta Entropy değeri $1$’dir. Tek bir sınıftan oluşan düğümde ise $0$ olur. Hesaplama sırasında $0\log_2(0)$ ifadesi limit yaklaşımıyla sıfır kabul edilir.</p>

<p>Entropy ile bölünme değerlendirilirken çoğunlukla <strong>Information Gain</strong> kullanılır:</p>

\[IG = H(parent)-\sum_j \frac{n_j}{n}H(child_j)\]

<p>Yani çocuk düğümlerin ağırlıklı belirsizliği, ebeveynin belirsizliğinden çıkarılır. En yüksek bilgi kazancını sağlayan bölünme seçilir.</p>

<table>
  <thead>
    <tr>
      <th>Özellik</th>
      <th>Gini Impurity</th>
      <th>Entropy</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Formül yapısı</td>
      <td>Kare alma</td>
      <td>Logaritma</td>
    </tr>
    <tr>
      <td>İkili sınıfta maksimum</td>
      <td>$0.5$</td>
      <td>$1$</td>
    </tr>
    <tr>
      <td>Hesaplama maliyeti</td>
      <td>Genellikle daha düşük</td>
      <td>Biraz daha yüksek</td>
    </tr>
    <tr>
      <td>Hassasiyet</td>
      <td>Baskın sınıfa odaklanabilir</td>
      <td>Nadir sınıflara biraz daha duyarlıdır</td>
    </tr>
    <tr>
      <td>Yaygın kullanım</td>
      <td>CART, scikit-learn varsayılanı</td>
      <td>ID3, C4.5 ve bilgi kazancı</td>
    </tr>
  </tbody>
</table>

<p><img src="/img/karar-agaclarinda-gini-71.svg" alt="karar-agaclarinda-gini-71" /></p>

<h2 id="bölünme-nasıl-puanlanır">Bölünme nasıl puanlanır?</h2>

<p>Bir aday bölünmenin kalitesi, çocuk düğümlerin ağırlıklı impurity değeriyle hesaplanır:</p>

\[I_{split}=\frac{n_L}{n}I_L+\frac{n_R}{n}I_R\]

<p>Amaç bu değeri küçültmek veya ebeveyn düğüme göre impurity azalmasını büyütmektir. Çok saf fakat yalnızca iki örnek içeren bir dalın ağacı yanıltmaması için örnek sayılarıyla ağırlıklandırma kritik öneme sahiptir.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="n">sklearn.tree</span> <span class="kn">import</span> <span class="n">DecisionTreeClassifier</span>

<span class="c1"># Aynı veri üzerinde iki farklı saflık ölçütü kullanan modeller
</span><span class="n">models</span> <span class="o">=</span> <span class="p">{</span>
    <span class="sh">'</span><span class="s">gini</span><span class="sh">'</span><span class="p">:</span> <span class="nc">DecisionTreeClassifier</span><span class="p">(</span><span class="n">criterion</span><span class="o">=</span><span class="sh">'</span><span class="s">gini</span><span class="sh">'</span><span class="p">,</span> <span class="n">random_state</span><span class="o">=</span><span class="mi">42</span><span class="p">),</span>
    <span class="sh">'</span><span class="s">entropy</span><span class="sh">'</span><span class="p">:</span> <span class="nc">DecisionTreeClassifier</span><span class="p">(</span><span class="n">criterion</span><span class="o">=</span><span class="sh">'</span><span class="s">entropy</span><span class="sh">'</span><span class="p">,</span> <span class="n">random_state</span><span class="o">=</span><span class="mi">42</span><span class="p">)</span>
<span class="p">}</span>

<span class="k">for</span> <span class="n">name</span><span class="p">,</span> <span class="n">model</span> <span class="ow">in</span> <span class="n">models</span><span class="p">.</span><span class="nf">items</span><span class="p">():</span>
    <span class="n">model</span><span class="p">.</span><span class="nf">fit</span><span class="p">(</span><span class="n">X_train</span><span class="p">,</span> <span class="n">y_train</span><span class="p">)</span>
    <span class="nf">print</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">model</span><span class="p">.</span><span class="nf">score</span><span class="p">(</span><span class="n">X_test</span><span class="p">,</span> <span class="n">y_test</span><span class="p">))</span>
</code></pre></div></div>

<p>Bu kod iki ağacı aynı eğitim verisiyle kurar ve test doğruluklarını karşılaştırır. Sağlıklı bir deneyde yalnızca doğruluğa değil; eğitim süresine, ağaç derinliğine, çapraz doğrulama skorlarına ve dengesiz veri varsa F1 ya da ROC-AUC değerlerine de bakılmalıdır.</p>

<h2 id="hangisini-seçmeliyiz">Hangisini seçmeliyiz?</h2>

<p>Pratikte iki kriter çoğu zaman benzer bölünmeler ve tahmin performansı üretir. Gini, logaritma hesaplamadığı için teorik olarak daha hızlıdır; Entropy ise olasılıklardaki değişimleri bilgi miktarı olarak yorumlamayı sağlar. Küçük hız farkları modern uygulamalarda genellikle belirleyici değildir.</p>

<p>En doğru yaklaşım, kriteri bir hiperparametre gibi değerlendirmektir. Çapraz doğrulamayla ikisini de deneyin; genelleme performansı, model karmaşıklığı ve çalışma süresi açısından daha uygun olanı seçin. Kısacası Gini hızlı bir saflık dedektörü, Entropy ise bilgi teorisi gözlüğü takmış meraklı bir matematikçidir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="makine öğrenmesi" /><category term="karar ağaçları" /><category term="gini impurity" /><category term="entropy" /><category term="python" /><category term="veri bilimi" /><summary type="html"><![CDATA[Bir karar ağacı, verileri dallara ayırırken sürekli aynı soruyu sorar: “Hangi bölünme, sınıfları birbirinden en iyi şekilde ayırır?” Bu soruyu yalnızca sezgilerle cevaplamak yerine düğümlerin ne kadar karışık olduğunu ölçeriz. Sınıflandırma ağaçlarında bu amaçla en sık kullanılan iki ölçüt Gini Impurity ve Entropy’dir. İkisi de aynı hedefe koşar; ancak hedefe giderken kullandıkları matematiksel rota biraz farklıdır.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/karar-agaclarinda-gini-71.png" /><media:content medium="image" url="https://program.sonsuz.us/img/karar-agaclarinda-gini-71.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">LightGBM’in Sırrı: Histogram Tabanlı Öğrenme ile XGBoost’u Nasıl Geçti?</title><link href="https://program.sonsuz.us/posts/lightgbmin-sirri-histogram-tabanli-ogrenme-ile-xgboostu-nasil-gecti/" rel="alternate" type="text/html" title="LightGBM’in Sırrı: Histogram Tabanlı Öğrenme ile XGBoost’u Nasıl Geçti?" /><published>2026-09-26T00:00:00+00:00</published><updated>2026-09-26T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/lightgbmin-sirri-histogram-tabanli-ogrenme-ile-xgboostu-nasil-gecti</id><content type="html" xml:base="https://program.sonsuz.us/posts/lightgbmin-sirri-histogram-tabanli-ogrenme-ile-xgboostu-nasil-gecti/"><![CDATA[<p>Gradient boosting dünyasında doğruluk kadar eğitim süresi ve bellek tüketimi de önemlidir. LightGBM, sürekli özelliklerdeki her değeri ayrı ayrı incelemek yerine değerleri küçük aralıklara, yani <strong>bin</strong> adı verilen sepetlere yerleştirerek bu dengeyi değiştirdi. Milyonlarca satırlık veriyle çalışan bir algoritma için bu yaklaşım, tek tek bozuk para saymak yerine onları önceden hazırlanmış kutularda tartmaya benzer.</p>

<p>``</p>

<h2 id="gradient-boosting-neden-pahalıdır">Gradient boosting neden pahalıdır?</h2>

<p>Gradient boosting, önceki ağaçların hatalarını azaltacak yeni karar ağaçlarını ardışık biçimde üretir. Modelin genel tahmini kabaca şöyle yazılabilir:</p>

\[F_t(x) = F_{t-1}(x) + \eta f_t(x)\]

<p>Burada $f_t(x)$ yeni ağacı, $\eta$ ise öğrenme oranını temsil eder. Her düğümde algoritmanın “Bu özelliği hangi değerden bölersem kayıp en fazla azalır?” sorusunu cevaplaması gerekir.</p>

<p>Klasik yaklaşımda sürekli bir özelliğin değerleri sıralanır ve olası eşikler değerlendirilir. $n$ örnek ve $m$ özellik için bu işlem büyük veri kümelerinde ciddi sıralama, tarama ve bellek maliyeti oluşturabilir. Üstelik aynı tür hesaplamalar ağacın birçok düğümünde tekrarlanır.</p>

<h2 id="histogram-numarası">Histogram numarası</h2>

<p>LightGBM, her sürekli özelliği genellikle birkaç yüz bin içine dönüştürür. Örneğin yaş değerleri tek tek tutulmak yerine <code class="language-plaintext highlighter-rouge">18-25</code>, <code class="language-plaintext highlighter-rouge">26-35</code> ve <code class="language-plaintext highlighter-rouge">36-50</code> gibi gruplara eşlenebilir. Gerçekte sınırlar veri dağılımına göre daha sistematik belirlenir.</p>

<p>Her bin için gradyan ve Hessian değerleri toplanır:</p>

\[G_b = \sum_{i \in b} g_i, \qquad H_b = \sum_{i \in b} h_i\]

<p>Bölünme kazancı artık bütün örnekler yerine bu özetler üzerinden hesaplanabilir. Böylece çalışma maliyeti örnek sayısından çok bin sayısına bağlı hâle gelir. Ayrıca ham ondalıklı değerler yerine küçük tamsayı bin kimlikleri saklanabildiği için bellek kullanımı azalır ve işlemci önbelleği daha verimli kullanılır.</p>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th style="text-align: right">Bölünme adayları</th>
      <th style="text-align: right">Bellek ihtiyacı</th>
      <th>Eğitim davranışı</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Geleneksel exact yöntem</td>
      <td style="text-align: right">Neredeyse tüm benzersiz değerler</td>
      <td style="text-align: right">Yüksek</td>
      <td>Küçük veride hassas, büyük veride pahalı</td>
    </tr>
    <tr>
      <td>Histogram yöntemi</td>
      <td style="text-align: right">Sınırlı sayıda bin</td>
      <td style="text-align: right">Daha düşük</td>
      <td>Büyük veride hızlı ve ölçeklenebilir</td>
    </tr>
    <tr>
      <td>Çok az bin</td>
      <td style="text-align: right">Çok az eşik</td>
      <td style="text-align: right">Çok düşük</td>
      <td>Hızlı fakat bilgi kaybına açık</td>
    </tr>
  </tbody>
</table>

<p><img src="/img/lightgbmin-sirri-histogram-54.svg" alt="lightgbmin-sirri-histogram-54" /></p>

<p>Histogramlar yalnızca hız sağlamaz. Bir düğümün histogramı ile çocuklarından birinin histogramı biliniyorsa diğer çocuk çıkarma işlemiyle bulunabilir. Bu <strong>histogram subtraction</strong> tekniği, aynı verinin tekrar tekrar taranmasını önler.</p>

<h2 id="lightgbmi-farklılaştıran-diğer-parçalar">LightGBM’i farklılaştıran diğer parçalar</h2>

<p>LightGBM’in avantajını yalnızca histogramlara bağlamak eksik olur. Algoritma çoğunlukla ağacı seviye seviye değil, kaybı en fazla azaltan yaprağı büyüterek oluşturur. <strong>Leaf-wise</strong> büyüme daha düşük kayba hızlı ulaşabilir; ancak küçük verilerde aşırı öğrenme riski taşır. Bu nedenle <code class="language-plaintext highlighter-rouge">num_leaves</code>, <code class="language-plaintext highlighter-rouge">max_depth</code> ve <code class="language-plaintext highlighter-rouge">min_data_in_leaf</code> kritik ayarlardır.</p>

<p>Ayrıca <strong>GOSS</strong>, gradyanı büyük örnekleri koruyup kolay örneklerden örnekleme yapar. <strong>EFB</strong> ise aynı anda sıfır olmayan seyrek özellikleri tek özellikte paketleyerek boyutu azaltır.</p>

<table>
  <thead>
    <tr>
      <th>Özellik</th>
      <th>LightGBM yaklaşımı</th>
      <th>Pratik sonuç</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Ağaç büyütme</td>
      <td>Leaf-wise</td>
      <td>Hızlı kayıp azalması, daha yüksek overfitting riski</td>
    </tr>
    <tr>
      <td>Örnek seçimi</td>
      <td>GOSS</td>
      <td>Daha az örnekle önemli hataları koruma</td>
    </tr>
    <tr>
      <td>Seyrek özellikler</td>
      <td>EFB</td>
      <td>Daha az özellik taraması</td>
    </tr>
    <tr>
      <td>Değer işleme</td>
      <td>Histogram binleri</td>
      <td>Daha düşük bellek ve daha hızlı eğitim</td>
    </tr>
  </tbody>
</table>

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

<p>Aşağıdaki kod, histogram çözünürlüğünü belirleyen <code class="language-plaintext highlighter-rouge">max_bin</code> seçeneğiyle bir sınıflandırıcı kurar:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="n">lightgbm</span> <span class="kn">import</span> <span class="n">LGBMClassifier</span>
<span class="kn">from</span> <span class="n">sklearn.metrics</span> <span class="kn">import</span> <span class="n">accuracy_score</span>

<span class="n">model</span> <span class="o">=</span> <span class="nc">LGBMClassifier</span><span class="p">(</span>
    <span class="n">n_estimators</span><span class="o">=</span><span class="mi">400</span><span class="p">,</span>
    <span class="n">learning_rate</span><span class="o">=</span><span class="mf">0.05</span><span class="p">,</span>
    <span class="n">num_leaves</span><span class="o">=</span><span class="mi">31</span><span class="p">,</span>
    <span class="n">max_bin</span><span class="o">=</span><span class="mi">255</span><span class="p">,</span>
    <span class="n">min_child_samples</span><span class="o">=</span><span class="mi">30</span><span class="p">,</span>
    <span class="n">random_state</span><span class="o">=</span><span class="mi">42</span>
<span class="p">)</span>

<span class="n">model</span><span class="p">.</span><span class="nf">fit</span><span class="p">(</span><span class="n">X_train</span><span class="p">,</span> <span class="n">y_train</span><span class="p">)</span>
<span class="n">predictions</span> <span class="o">=</span> <span class="n">model</span><span class="p">.</span><span class="nf">predict</span><span class="p">(</span><span class="n">X_test</span><span class="p">)</span>
<span class="nf">print</span><span class="p">(</span><span class="nf">accuracy_score</span><span class="p">(</span><span class="n">y_test</span><span class="p">,</span> <span class="n">predictions</span><span class="p">))</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">max_bin</code> artırılırsa daha hassas eşikler elde edilebilir; fakat eğitim ve bellek maliyeti yükselir. Azaltılırsa model hızlanır, ancak önemli ayrımlar aynı sepete düşebilir.</p>

<p>Sonuç olarak LightGBM, özellikle büyük ve yüksek boyutlu verilerde XGBoost’un tarihsel exact yaklaşımını hız ve bellek bakımından geçebildi. Güncel XGBoost sürümlerinin de histogram tabanlı yöntemler sunduğunu unutmamak gerekir; dolayısıyla mutlak bir şampiyon yoktur. Asıl sır, daha fazla hesaplamak değil, veriyi akıllıca özetleyerek doğru hesapları yapmaktır.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="lightgbm" /><category term="xgboost" /><category term="gradient-boosting" /><category term="makine-öğrenmesi" /><category term="histogram" /><category term="python" /><summary type="html"><![CDATA[Gradient boosting dünyasında doğruluk kadar eğitim süresi ve bellek tüketimi de önemlidir. LightGBM, sürekli özelliklerdeki her değeri ayrı ayrı incelemek yerine değerleri küçük aralıklara, yani bin adı verilen sepetlere yerleştirerek bu dengeyi değiştirdi. Milyonlarca satırlık veriyle çalışan bir algoritma için bu yaklaşım, tek tek bozuk para saymak yerine onları önceden hazırlanmış kutularda tartmaya benzer.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/lightgbmin-sirri-histogram-54.png" /><media:content medium="image" url="https://program.sonsuz.us/img/lightgbmin-sirri-histogram-54.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Makine Çevirisinde BLEU Skoru Bizi Kandırıyor mu?</title><link href="https://program.sonsuz.us/posts/makine-cevirisinde-bleu-skoru-bizi-kandiriyor-mu/" rel="alternate" type="text/html" title="Makine Çevirisinde BLEU Skoru Bizi Kandırıyor mu?" /><published>2026-09-26T00:00:00+00:00</published><updated>2026-09-26T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/makine-cevirisinde-bleu-skoru-bizi-kandiriyor-mu</id><content type="html" xml:base="https://program.sonsuz.us/posts/makine-cevirisinde-bleu-skoru-bizi-kandiriyor-mu/"><![CDATA[<p><img src="/img/makine-cevirisinde-bleu-94.svg" alt="makine-cevirisinde-bleu-94" /></p>

<p>Bir çeviri sistemi yüksek BLEU skoru aldığında gerçekten iyi çeviri yapıyor diyebilir miyiz? Kısa cevap: Her zaman değil. BLEU, makine çevirisi dünyasının en meşhur ölçüm araçlarından biri olsa da anlamı, akıcılığı ve bağlamı doğrudan ölçmez. Üstelik bazen kulağa robotik gelen bir çeviriyi ödüllendirirken gayet doğal bir alternatifi cezalandırabilir.</p>

<p>``</p>

<h2 id="bleu-aslında-neyi-ölçüyor">BLEU aslında neyi ölçüyor?</h2>

<p>BLEU, yani <strong>Bilingual Evaluation Understudy</strong>, aday çevirideki kelime dizilerini insan tarafından hazırlanmış referans çevirilerle karşılaştırır. Buradaki temel fikir, iki metnin ortak $n$-gram sayısı arttıkça çevirinin daha başarılı kabul edilmesidir.</p>

<p>Bir $n$-gram, art arda gelen $n$ adet parçadan oluşur:</p>

<ul>
  <li>1-gram: <code class="language-plaintext highlighter-rouge">yapay</code></li>
  <li>2-gram: <code class="language-plaintext highlighter-rouge">yapay zeka</code></li>
  <li>3-gram: <code class="language-plaintext highlighter-rouge">yapay zeka sistemi</code></li>
</ul>

<p>Basitleştirilmiş $n$-gram kesinliği şöyle gösterilebilir:</p>

\[p_n = \frac{\text{Eşleşen aday n-gram sayısı}}{\text{Adaydaki toplam n-gram sayısı}}\]

<p>BLEU, farklı uzunluklardaki $n$-gram kesinliklerinin geometrik ortalamasını alır ve çok kısa çevirileri engellemek için bir uzunluk cezası ekler:</p>

\[BLEU = BP \cdot \exp\left(\sum_{n=1}^{N} w_n \log p_n\right)\]

<p>Buradaki $BP$, <strong>brevity penalty</strong> olarak bilinen kısalık cezasıdır. Sistem yalnızca birkaç doğru kelime üretip yüksek puanı kapamasın diye kullanılır.</p>

<h2 id="aynı-anlam-farklı-kelimeler">Aynı anlam, farklı kelimeler</h2>

<p>Kaynak cümlenin “The meeting was called off” olduğunu düşünelim. Referans çeviri “Toplantı iptal edildi” olsun.</p>

<table>
  <thead>
    <tr>
      <th>Aday çeviri</th>
      <th style="text-align: right">Anlamsal kalite</th>
      <th>BLEU açısından durum</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Toplantı iptal edildi</td>
      <td style="text-align: right">Yüksek</td>
      <td>Tam eşleşme</td>
    </tr>
    <tr>
      <td>Görüşme iptal oldu</td>
      <td style="text-align: right">Yüksek</td>
      <td>Düşük kelime eşleşmesi</td>
    </tr>
    <tr>
      <td>Toplantı edildi iptal</td>
      <td style="text-align: right">Düşük</td>
      <td>Bazı n-gramlar eşleşebilir</td>
    </tr>
    <tr>
      <td>Toplantı ertelendi</td>
      <td style="text-align: right">Yanlış</td>
      <td>“Toplantı” nedeniyle kısmi puan alabilir</td>
    </tr>
  </tbody>
</table>

<p>İkinci çeviri bağlama göre son derece doğal olabilir. Ancak BLEU, “görüşme” ile “toplantı” arasındaki yakınlığı veya “iptal oldu” ifadesinin aynı mesajı taşıdığını bilmez. Çünkü kelimelerin anlamlarını değil, yüzeydeki parçaların örtüşmesini sayar.</p>

<p>Bu durum özellikle eş anlamlıların bol olduğu dillerde, serbest sözcük diziliminde ve Türkçe gibi eklemeli dillerde belirginleşir. “Evlerimizden” tek bir kelimeyken başka bir dilde birkaç ayrı sözcüğe karşılık gelebilir. Tokenizasyon tercihi bile sonucu değiştirebilir.</p>

<h2 id="skoru-hızlıca-hesaplamak">Skoru hızlıca hesaplamak</h2>

<p>Python’da <code class="language-plaintext highlighter-rouge">sacrebleu</code> paketiyle standartlaştırılmış bir BLEU hesabı yapılabilir:</p>

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

<span class="n">referanslar</span> <span class="o">=</span> <span class="p">[[</span><span class="sh">'</span><span class="s">Toplantı iptal edildi</span><span class="sh">'</span><span class="p">]]</span>
<span class="n">adaylar</span> <span class="o">=</span> <span class="p">[</span><span class="sh">'</span><span class="s">Görüşme iptal oldu</span><span class="sh">'</span><span class="p">]</span>

<span class="n">sonuc</span> <span class="o">=</span> <span class="n">sacrebleu</span><span class="p">.</span><span class="nf">corpus_bleu</span><span class="p">(</span><span class="n">adaylar</span><span class="p">,</span> <span class="n">referanslar</span><span class="p">)</span>
<span class="nf">print</span><span class="p">(</span><span class="sa">f</span><span class="sh">'</span><span class="s">BLEU: </span><span class="si">{</span><span class="n">sonuc</span><span class="p">.</span><span class="n">score</span><span class="si">:</span><span class="p">.</span><span class="mi">2</span><span class="n">f</span><span class="si">}</span><span class="sh">'</span><span class="p">)</span>
</code></pre></div></div>

<p>Bu kod aday çeviriyi referansla karşılaştırır. Sonuç düşük çıkarsa adayın mutlaka kötü olduğunu söyleyemeyiz; yalnızca referansın kelime dizilimine yeterince benzemediğini söyleyebiliriz. Ayrıca farklı kütüphanelerin tokenizasyon ve düzeltme yöntemleri farklı sonuçlar üretebildiğinden deneylerde kullanılan BLEU sürümü açıkça belirtilmelidir.</p>

<h2 id="bleu-ne-zaman-işe-yarar">BLEU ne zaman işe yarar?</h2>

<p>BLEU tamamen kullanışsız değildir. Büyük veri kümelerinde, aynı test seti üzerinde eğitilen sistemlerin genel ilerlemesini hızlı ve ucuz biçimde karşılaştırmak için pratiktir. Ancak tek bir cümlenin kalitesini değerlendirmekte güvenilir değildir. Korpus düzeyinde anlamlı olan istatistikler, cümle düzeyinde oynak hale gelir.</p>

<table>
  <thead>
    <tr>
      <th>Yöntem</th>
      <th>Güçlü yanı</th>
      <th>Temel kusuru</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>BLEU</td>
      <td>Hızlı ve tekrarlanabilir</td>
      <td>Anlamı doğrudan ölçmez</td>
    </tr>
    <tr>
      <td>chrF</td>
      <td>Karakter ve ek benzerliğine duyarlı</td>
      <td>Bağlam bilgisi sınırlıdır</td>
    </tr>
    <tr>
      <td>COMET</td>
      <td>Anlamsal ilişkileri modelleyebilir</td>
      <td>Eğitildiği verilere bağımlıdır</td>
    </tr>
    <tr>
      <td>İnsan değerlendirmesi</td>
      <td>Akıcılık ve doğruluğu birlikte görebilir</td>
      <td>Pahalı ve öznel olabilir</td>
    </tr>
  </tbody>
</table>

<h2 id="tek-sayı-yerine-ölçüm-sepeti">Tek sayı yerine ölçüm sepeti</h2>

<p>Sağlıklı değerlendirme için BLEU; chrF, COMET veya BERTScore gibi metriklerle desteklenmelidir. Kritik uygulamalarda insan değerlendiriciler doğruluk, akıcılık, terminoloji ve kültürel uygunluk başlıklarını ayrı ayrı puanlamalıdır.</p>

<p>Sonuç olarak BLEU bizi bilinçli biçimde kandırmaz; yalnızca kendisine sormadığımız soruları cevaplayamaz. O, “Bu çeviri referansa ne kadar benziyor?” sorusunda iyidir. “Bu çeviri anlamı doğru, doğal ve güvenli biçimde aktarıyor mu?” sorusu içinse tek başına oldukça sessizdir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="bleu" /><category term="makine çevirisi" /><category term="doğal dil işleme" /><category term="yapay zeka" /><category term="değerlendirme metrikleri" /><summary type="html"><![CDATA[Bir çeviri sistemi yüksek BLEU skoru aldığında gerçekten iyi çeviri yapıyor diyebilir miyiz? Kısa cevap: Her zaman değil. BLEU, makine çevirisi dünyasının en meşhur ölçüm araçlarından biri olsa da anlamı, akıcılığı ve bağlamı doğrudan ölçmez. Üstelik bazen kulağa robotik gelen bir çeviriyi ödüllendirirken gayet doğal bir alternatifi cezalandırabilir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/makine-cevirisinde-bleu-94.png" /><media:content medium="image" url="https://program.sonsuz.us/img/makine-cevirisinde-bleu-94.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Transfer Öğrenme ile Küçük Veriden Büyük Sonuçlar Çıkarmak</title><link href="https://program.sonsuz.us/posts/transfer-ogrenme-ile-kucuk-veriden-buyuk-sonuclar-cikarmak/" rel="alternate" type="text/html" title="Transfer Öğrenme ile Küçük Veriden Büyük Sonuçlar Çıkarmak" /><published>2026-09-26T00:00:00+00:00</published><updated>2026-09-26T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/transfer-ogrenme-ile-kucuk-veriden-buyuk-sonuclar-cikarmak</id><content type="html" xml:base="https://program.sonsuz.us/posts/transfer-ogrenme-ile-kucuk-veriden-buyuk-sonuclar-cikarmak/"><![CDATA[<p>Bir görüntü sınıflandırma modeli geliştirmek istiyorsunuz ancak elinizde yalnızca birkaç yüz örnek var. Sıfırdan eğitilen dev bir sinir ağı bu veriyi ezberleyip gerçek dünyada tökezleyebilir. Neyse ki teknoloji devlerinin milyonlarca örnekle eğittiği modellerin öğrendiği zihinsel haritaları ödünç alabiliriz. <strong>Transfer öğrenme</strong>, küçük veri setlerinin süper gücü tam olarak budur.
``</p>

<h2 id="transfer-öğrenme-nedir">Transfer öğrenme nedir?</h2>

<p>Derin sinir ağlarının ilk katmanları kenar, renk ve doku gibi genel örüntüleri; ilerleyen katmanları ise nesne parçaları ve sınıfa özgü yapıları öğrenir. Bir kediyi tanımak için öğrenilen kenar dedektörleri, otomobil veya yaprak sınıflandırırken de işe yarar. Böylece modelin bütün bilgisini çöpe atmak yerine yalnızca probleminize özgü bölümünü değiştirirsiniz.</p>

<p>Kaynak görevde öğrenilen parametreleri $w_s$, hedef görev için aradığımız parametreleri $w_t$ ile gösterelim. Transfer öğrenmenin temel fikri şudur:</p>

\[w_t^{(0)} = w_s\]

<p>Yani hedef model rastgele başlamaz; eğitim maratonuna başlangıç çizgisinden değil, parkurun büyük bölümünü tamamlamış halde girer. Ardından hedef veri üzerindeki kayıp fonksiyonu küçültülür:</p>

\[w_t^* = \arg\min_w \frac{1}{N}\sum_{i=1}^{N} L(f(x_i;w), y_i)\]

<p>$N$ küçük olduğunda iyi bir başlangıç noktası, aşırı öğrenme riskini ciddi biçimde azaltabilir.</p>

<h2 id="i̇ki-temel-strateji">İki temel strateji</h2>

<table>
  <thead>
    <tr>
      <th>Strateji</th>
      <th>Katmanların durumu</th>
      <th style="text-align: right">Veri ihtiyacı</th>
      <th>Ne zaman kullanılmalı?</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Özellik çıkarımı</td>
      <td>Omurga dondurulur</td>
      <td style="text-align: right">Çok düşük</td>
      <td>Veri az ve kaynak görev benzerse</td>
    </tr>
    <tr>
      <td>İnce ayar</td>
      <td>Bazı katmanlar açılır</td>
      <td style="text-align: right">Orta</td>
      <td>Veri daha fazla veya alan farklıysa</td>
    </tr>
    <tr>
      <td>Sıfırdan eğitim</td>
      <td>Tüm ağırlıklar rastgele</td>
      <td style="text-align: right">Çok yüksek</td>
      <td>Büyük ve özgün bir veri seti varsa</td>
    </tr>
  </tbody>
</table>

<p><strong>Özellik çıkarımında</strong> önceden eğitilmiş ağ sabit bir dönüştürücü gibi davranır. Sadece son sınıflandırma katmanı eğitilir. <strong>İnce ayarda</strong> ise üst katmanlardan bazıları düşük öğrenme oranıyla güncellenir. Bu, modele “Bildiklerini unutma ama bizim lehçemizi de öğren” demektir.</p>

<h2 id="pytorch-ile-uygulama">PyTorch ile uygulama</h2>

<p>Aşağıdaki örnek, ImageNet üzerinde eğitilmiş ResNet18 modelini üç sınıflı bir problem için hazırlar:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="n">torch.nn</span> <span class="k">as</span> <span class="n">nn</span>
<span class="kn">from</span> <span class="n">torchvision.models</span> <span class="kn">import</span> <span class="n">resnet18</span><span class="p">,</span> <span class="n">ResNet18_Weights</span>

<span class="n">model</span> <span class="o">=</span> <span class="nf">resnet18</span><span class="p">(</span><span class="n">weights</span><span class="o">=</span><span class="n">ResNet18_Weights</span><span class="p">.</span><span class="n">DEFAULT</span><span class="p">)</span>

<span class="c1"># Önceden öğrenilmiş özellikleri koru.
</span><span class="k">for</span> <span class="n">parameter</span> <span class="ow">in</span> <span class="n">model</span><span class="p">.</span><span class="nf">parameters</span><span class="p">():</span>
    <span class="n">parameter</span><span class="p">.</span><span class="n">requires_grad</span> <span class="o">=</span> <span class="bp">False</span>

<span class="c1"># Eski 1000 sınıflı çıkışı kendi problemimize uyarla.
</span><span class="n">input_features</span> <span class="o">=</span> <span class="n">model</span><span class="p">.</span><span class="n">fc</span><span class="p">.</span><span class="n">in_features</span>
<span class="n">model</span><span class="p">.</span><span class="n">fc</span> <span class="o">=</span> <span class="n">nn</span><span class="p">.</span><span class="nc">Linear</span><span class="p">(</span><span class="n">input_features</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
</code></pre></div></div>

<p>Burada omurganın parametreleri dondurulur, ancak yeni <code class="language-plaintext highlighter-rouge">model.fc</code> katmanı varsayılan olarak eğitilebilir durumdadır. Optimize ediciye yalnızca güncellenecek parametreleri vermek gereksiz hesaplamayı önler:</p>

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

<span class="n">optimizer</span> <span class="o">=</span> <span class="n">optim</span><span class="p">.</span><span class="nc">Adam</span><span class="p">(</span>
    <span class="nf">filter</span><span class="p">(</span><span class="k">lambda</span> <span class="n">p</span><span class="p">:</span> <span class="n">p</span><span class="p">.</span><span class="n">requires_grad</span><span class="p">,</span> <span class="n">model</span><span class="p">.</span><span class="nf">parameters</span><span class="p">()),</span>
    <span class="n">lr</span><span class="o">=</span><span class="mf">1e-3</span>
<span class="p">)</span>
<span class="n">criterion</span> <span class="o">=</span> <span class="n">nn</span><span class="p">.</span><span class="nc">CrossEntropyLoss</span><span class="p">()</span>
</code></pre></div></div>

<p>İlk eğitimden sonra doğrulama başarımı tıkanırsa son katman grubunu açarak ince ayar yapabiliriz:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">for</span> <span class="n">parameter</span> <span class="ow">in</span> <span class="n">model</span><span class="p">.</span><span class="n">layer4</span><span class="p">.</span><span class="nf">parameters</span><span class="p">():</span>
    <span class="n">parameter</span><span class="p">.</span><span class="n">requires_grad</span> <span class="o">=</span> <span class="bp">True</span>

<span class="n">optimizer</span> <span class="o">=</span> <span class="n">optim</span><span class="p">.</span><span class="nc">Adam</span><span class="p">(</span>
    <span class="nf">filter</span><span class="p">(</span><span class="k">lambda</span> <span class="n">p</span><span class="p">:</span> <span class="n">p</span><span class="p">.</span><span class="n">requires_grad</span><span class="p">,</span> <span class="n">model</span><span class="p">.</span><span class="nf">parameters</span><span class="p">()),</span>
    <span class="n">lr</span><span class="o">=</span><span class="mf">1e-5</span>
<span class="p">)</span>
</code></pre></div></div>

<p>Düşük öğrenme oranı önemlidir; büyük adımlar, önceden öğrenilmiş yararlı temsilleri bozarak <strong>felaket unutmaya</strong> yol açabilir.</p>

<h2 id="küçük-veriyi-daha-da-verimli-kullanmak">Küçük veriyi daha da verimli kullanmak</h2>

<p>Veri artırma sırasında döndürme, kırpma, renk değişimi ve yatay çevirme gibi işlemler uygulanabilir. Ancak tıbbi görüntüler veya yönün anlam taşıdığı veriler için her dönüşüm mantıklı değildir. Dikey çevrilmiş bir trafik levhası modele yaratıcılık değil, kafa karışıklığı kazandırabilir.</p>

<p>Eğitim ve doğrulama kümelerini dikkatle ayırmak, sınıf dengesini izlemek ve erken durdurma kullanmak da önemlidir. Başarıyı yalnızca doğrulukla ölçmeyin; dengesiz veri setlerinde precision, recall ve F1 skoru daha açıklayıcıdır.</p>

<p>Transfer öğrenme sihirli değnek değildir: Kaynak ve hedef alanlar çok farklıysa <strong>negatif transfer</strong> oluşabilir. Yine de doğru model, kontrollü ince ayar ve gerçekçi doğrulama ile birkaç yüz örnekten şaşırtıcı derecede güçlü sistemler üretmek mümkündür. Kısacası devlerin omzuna çıkın; fakat direksiyonu kendi probleminize göre çevirmeyi unutmayın.</p>

<p><img src="/img/transfer-ogrenme-ile-22.svg" alt="transfer-ogrenme-ile-22" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="transfer öğrenme" /><category term="makine öğrenmesi" /><category term="derin öğrenme" /><category term="yapay zeka" /><category term="python" /><category term="pytorch" /><summary type="html"><![CDATA[Bir görüntü sınıflandırma modeli geliştirmek istiyorsunuz ancak elinizde yalnızca birkaç yüz örnek var. Sıfırdan eğitilen dev bir sinir ağı bu veriyi ezberleyip gerçek dünyada tökezleyebilir. Neyse ki teknoloji devlerinin milyonlarca örnekle eğittiği modellerin öğrendiği zihinsel haritaları ödünç alabiliriz. Transfer öğrenme, küçük veri setlerinin süper gücü tam olarak budur.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/transfer-ogrenme-ile-22.png" /><media:content medium="image" url="https://program.sonsuz.us/img/transfer-ogrenme-ile-22.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Yapay Sinir Ağlarında Dropout: Nöronları Tembellikten Kurtarmak</title><link href="https://program.sonsuz.us/posts/yapay-sinir-aglarinda-dropout-noronlari-tembellikten-kurtarmak/" rel="alternate" type="text/html" title="Yapay Sinir Ağlarında Dropout: Nöronları Tembellikten Kurtarmak" /><published>2026-09-26T00:00:00+00:00</published><updated>2026-09-26T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/yapay-sinir-aglarinda-dropout-noronlari-tembellikten-kurtarmak</id><content type="html" xml:base="https://program.sonsuz.us/posts/yapay-sinir-aglarinda-dropout-noronlari-tembellikten-kurtarmak/"><![CDATA[<p><img src="/img/yapay-sinir-aglarinda-24.svg" alt="yapay-sinir-aglarinda-24" /></p>

<p>Bir yapay sinir ağı eğitim verisini ezberlemeye başladığında, sınıfın çalışkan öğrencisi gibi görünür; ancak sınav soruları değişince afallar. Dropout, eğitim sırasında bazı nöronları rastgele devre dışı bırakarak bu ezberciliğe müdahale eder. Böylece ağ, bütün yükü birkaç güçlü bağlantının üzerine yıkmak yerine farklı özelliklerden yararlanmayı öğrenir.
``</p>

<h2 id="dropout-tam-olarak-ne-yapar">Dropout tam olarak ne yapar?</h2>

<p>Standart bir katmanda her nöron, önceki katmandan gelen bilgiyi işler ve sonucunu sonraki katmana aktarır. Dropout kullanıldığında ise eğitimde her nöron belirli bir olasılıkla geçici olarak kapatılır. Kapatılan nöron o ileri geçişte çıktı üretmez ve geri yayılım sırasında güncellenmez.</p>

<p>Bir nöronun normal çıktısı $h_i$ olsun. Dropout sonrasında kullanılan çıktı şöyle gösterilebilir:</p>

\[\tilde{h}_i = m_i h_i, \quad m_i \sim Bernoulli(1-p)\]

<p>Burada $p$, nöronun kapatılma olasılığıdır. Örneğin $p=0.5$ seçilirse nöronların yaklaşık yarısı her eğitim adımında uyku molasına çıkar. Fakat hangi nöronların kapatılacağı sürekli değiştiği için kimse kalıcı olarak işten kaçamaz.</p>

<p>Modern kütüphaneler genellikle <strong>inverted dropout</strong> uygular:</p>

\[\tilde{h}_i = \frac{m_i h_i}{1-p}\]

<p>Bu ölçekleme, eğitim sırasındaki beklenen aktivasyonu korur. Böylece tahmin aşamasında ayrıca çıktı düzeltmesi yapmak gerekmez.</p>

<h2 id="ağdaki-tembellik-problemi">Ağdaki “tembellik” problemi</h2>

<p>Bir ağdaki bazı nöronlar belirli özelliklere aşırı güvenebilir. Örneğin bir kedi sınıflandırıcısı kulak, göz ve gövde biçimini birlikte öğrenmek yerine yalnızca arka plandaki koltuğa odaklanabilir. Eğitim verisindeki kediler çoğunlukla koltuk üzerindeyse sonuç harika görünür; dışarıdaki bir kedi gösterildiğinde model şaşırır.</p>

<p>Dropout, koltuğu algılayan nöronun her zaman kullanılacağını garanti etmez. Bu nedenle diğer nöronlar kulak, bıyık ve pati gibi alternatif ipuçlarını öğrenmek zorunda kalır. Bu davranışa <strong>eş-uyarlanmanın azaltılması</strong> denir.</p>

<table>
  <thead>
    <tr>
      <th>Dropout olmadan</th>
      <th>Dropout ile</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Nöronlar birbirine aşırı bağımlı olabilir</td>
      <td>Nöronlar daha bağımsız özellikler öğrenir</td>
    </tr>
    <tr>
      <td>Eğitim başarısı çok hızlı yükselir</td>
      <td>Eğitim daha zor ve dalgalı ilerleyebilir</td>
    </tr>
    <tr>
      <td>Overfitting riski yüksektir</td>
      <td>Genelleme performansı artabilir</td>
    </tr>
    <tr>
      <td>Tek ve sabit bir ağ eğitilir</td>
      <td>Çok sayıda alt ağ dolaylı biçimde eğitilir</td>
    </tr>
  </tbody>
</table>

<h2 id="neden-genellemeyi-artırır">Neden genellemeyi artırır?</h2>

<p>Her rastgele dropout maskesi, ana ağın farklı bir alt ağını oluşturur. Eğitim boyunca çok sayıda alt ağ aynı parametreleri paylaşarak öğrenir. Tahmin sırasında bütün nöronlar etkinleştirildiğinde ise yaklaşık bir <strong>model topluluğu</strong> elde edilir. Binlerce modeli ayrı ayrı eğitmek yerine, tek ağ içinde ekonomik bir ensemble etkisi oluşur.</p>

<p>Dropout aynı zamanda gürültü ekleyen bir düzenlileştirme yöntemidir. Model, her adımda değişen iç temsillere rağmen doğru sonucu üretmeye zorlanır. Bu durum, küçük ayrıntılara aşırı uyum sağlamak yerine daha dayanıklı örüntüler keşfetmesine yardımcı olur.</p>

<h2 id="pytorch-ile-kullanım">PyTorch ile kullanım</h2>

<p>Aşağıdaki ağ, gizli katmandan sonra aktivasyonların yüzde 30’unu rastgele kapatır:</p>

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

<span class="k">class</span> <span class="nc">Siniflandirici</span><span class="p">(</span><span class="n">nn</span><span class="p">.</span><span class="n">Module</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="nf">super</span><span class="p">().</span><span class="nf">__init__</span><span class="p">()</span>
        <span class="n">self</span><span class="p">.</span><span class="n">model</span> <span class="o">=</span> <span class="n">nn</span><span class="p">.</span><span class="nc">Sequential</span><span class="p">(</span>
            <span class="n">nn</span><span class="p">.</span><span class="nc">Linear</span><span class="p">(</span><span class="mi">100</span><span class="p">,</span> <span class="mi">64</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="nc">ReLU</span><span class="p">(),</span>
            <span class="n">nn</span><span class="p">.</span><span class="nc">Dropout</span><span class="p">(</span><span class="n">p</span><span class="o">=</span><span class="mf">0.3</span><span class="p">),</span>
            <span class="n">nn</span><span class="p">.</span><span class="nc">Linear</span><span class="p">(</span><span class="mi">64</span><span class="p">,</span> <span class="mi">10</span><span class="p">)</span>
        <span class="p">)</span>

    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="n">self</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
        <span class="k">return</span> <span class="n">self</span><span class="p">.</span><span class="nf">model</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">model.train()</code> çağrıldığında dropout aktiftir. Doğrulama veya tahmin öncesinde <code class="language-plaintext highlighter-rouge">model.eval()</code> kullanıldığında kapatılır. Bu ayrım unutulursa sonuçlar her çalıştırmada değişebilir.</p>

<h2 id="dropout-oranı-nasıl-seçilir">Dropout oranı nasıl seçilir?</h2>

<table>
  <thead>
    <tr>
      <th>Oran</th>
      <th>Olası sonuç</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>$0.1$–$0.2$</td>
      <td>Hafif düzenlileştirme</td>
    </tr>
    <tr>
      <td>$0.3$–$0.5$</td>
      <td>Yoğun katmanlarda güçlü başlangıç noktası</td>
    </tr>
    <tr>
      <td>$0.6$ ve üzeri</td>
      <td>Öğrenmeyi ciddi biçimde zorlaştırabilir</td>
    </tr>
  </tbody>
</table>

<p>Dropout sihirli değnek değildir. Çok küçük veri kümelerinde faydalı olabilirken batch normalization, veri artırma ve ağırlık çürümesiyle birlikte etkisi değişebilir. Özellikle evrişimli ağlarda daha düşük oranlar tercih edilir; bazı modern transformer mimarilerinde ise attention ve bağlantı çıkışlarına uygulanır.</p>

<p>Özetle dropout, nöronları cezalandırmaz; onları takım arkadaşları olmadan da iş yapabilecek şekilde eğitir. Sonuç, tek bir ipucuna bağlanmayan, sürpriz veriler karşısında daha az paniğe kapılan ve gerçek dünyaya daha iyi uyum sağlayan bir modeldir.</p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="yapay zeka" /><category term="derin öğrenme" /><category term="dropout" /><category term="sinir ağları" /><category term="makine öğrenmesi" /><category term="overfitting" /><summary type="html"><![CDATA[Bir yapay sinir ağı eğitim verisini ezberlemeye başladığında, sınıfın çalışkan öğrencisi gibi görünür; ancak sınav soruları değişince afallar. Dropout, eğitim sırasında bazı nöronları rastgele devre dışı bırakarak bu ezberciliğe müdahale eder. Böylece ağ, bütün yükü birkaç güçlü bağlantının üzerine yıkmak yerine farklı özelliklerden yararlanmayı öğrenir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/yapay-sinir-aglarinda-24.png" /><media:content medium="image" url="https://program.sonsuz.us/img/yapay-sinir-aglarinda-24.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Yönlendirilmiş Dikkat: Sinir Ağlarının Görsel Odak Noktası</title><link href="https://program.sonsuz.us/posts/yonlendirilmis-dikkat-sinir-aglarinin-gorsel-odak-noktasi/" rel="alternate" type="text/html" title="Yönlendirilmiş Dikkat: Sinir Ağlarının Görsel Odak Noktası" /><published>2026-09-26T00:00:00+00:00</published><updated>2026-09-26T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/yonlendirilmis-dikkat-sinir-aglarinin-gorsel-odak-noktasi</id><content type="html" xml:base="https://program.sonsuz.us/posts/yonlendirilmis-dikkat-sinir-aglarinin-gorsel-odak-noktasi/"><![CDATA[<p>Bir fotoğrafta kedi ararken duvardaki çatlakları, masanın desenini veya perde kıvrımlarını uzun uzun incelemeyiz; gözümüz hızla kulak, göz ve pati gibi ayırt edici bölgelere yönelir. Yönlendirilmiş dikkat (targeted attention), sinir ağlarına benzer bir seçicilik kazandırır. Model bütün pikselleri eşit derecede önemli kabul etmek yerine, yaptığı görev açısından anlamlı bölgelere daha yüksek ağırlık verir. Böylece hem tahminler iyileşebilir hem de ağın kararını nereden çıkardığı daha anlaşılır hâle gelebilir.</p>

<p>``</p>

<h2 id="dikkat-mekanizmasının-temel-fikri">Dikkat mekanizmasının temel fikri</h2>

<p>Bir evrişimli sinir ağı, görüntüyü doğrudan “kedi” veya “otomobil” olarak görmez. Ara katmanlarda $H \times W \times C$ boyutlu özellik haritaları üretir. Burada $H$ ve $W$ uzamsal boyutları, $C$ ise kanal sayısını temsil eder. Dikkat modülü bu özellikler için genellikle $0$ ile $1$ arasında ağırlıklar hesaplar.</p>

<p>Bir konumdaki özellik vektörü $x_i$, dikkat puanı ise $a_i$ olsun. Dikkatli temsil şu şekilde yazılabilir:</p>

\[z = \sum_{i=1}^{N} \alpha_i x_i, \qquad
\alpha_i = \frac{e^{a_i}}{\sum_{j=1}^{N} e^{a_j}}\]

<p>Softmax sayesinde $\sum_i \alpha_i=1$ olur. Yani model, elindeki sınırlı “ilgi bütçesini” görüntünün farklı bölgelerine dağıtır. Yüksek $\alpha_i$ alan pikseller veya yamalar kararda daha etkili olur.</p>

<h2 id="hangi-dikkat-türü-neye-odaklanır">Hangi dikkat türü neye odaklanır?</h2>

<table>
  <thead>
    <tr>
      <th>Yaklaşım</th>
      <th>Odaklandığı şey</th>
      <th>Güçlü yanı</th>
      <th>Sınırlaması</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Uzamsal dikkat</td>
      <td>Görüntüdeki konumlar</td>
      <td>Nesnenin bulunduğu alanı vurgular</td>
      <td>Arka plan ipuçlarına aldanabilir</td>
    </tr>
    <tr>
      <td>Kanal dikkati</td>
      <td>Özellik kanalları</td>
      <td>Renk, kenar veya doku filtrelerini seçer</td>
      <td>Konumu doğrudan açıklamaz</td>
    </tr>
    <tr>
      <td>Self-attention</td>
      <td>Bölgeler arası ilişkiler</td>
      <td>Uzak pikselleri ilişkilendirir</td>
      <td>Hesaplama maliyeti büyüyebilir</td>
    </tr>
    <tr>
      <td>Sert dikkat</td>
      <td>Seçilen birkaç bölge</td>
      <td>Verimli ve keskin odak sağlar</td>
      <td>Ayrık seçim nedeniyle eğitimi zordur</td>
    </tr>
    <tr>
      <td>Yumuşak dikkat</td>
      <td>Tüm bölgelere ağırlık verir</td>
      <td>Türevlenebilir ve kolay eğitilir</td>
      <td>Gereksiz bölgelere küçük de olsa pay ayırır</td>
    </tr>
  </tbody>
</table>

<p>“Yönlendirilmiş” ifadesi, dikkatin yalnızca görüntü içinden kendiliğinden doğması gerekmediğini de anlatır. Bir sınıf etiketi, metin sorgusu, nesne koordinatı veya önceki video karesi hedef sinyali olabilir. Örneğin “kırmızı çantayı bul” sorgusu verildiğinde model hem kırmızılığa hem de çantaya benzeyen şekillere odaklanır.</p>

<h2 id="basit-bir-uzamsal-dikkat-modülü">Basit bir uzamsal dikkat modülü</h2>

<p>Aşağıdaki PyTorch modülü, kanal boyunca ortalama ve maksimum özet çıkarır. Ardından bir evrişim ve sigmoid kullanarak tek kanallı dikkat haritası üretir. Son çarpma işlemi önemli bölgeleri güçlendirir:</p>

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

<span class="k">class</span> <span class="nc">SpatialAttention</span><span class="p">(</span><span class="n">nn</span><span class="p">.</span><span class="n">Module</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">kernel_size</span><span class="o">=</span><span class="mi">7</span><span class="p">):</span>
        <span class="nf">super</span><span class="p">().</span><span class="nf">__init__</span><span class="p">()</span>
        <span class="n">padding</span> <span class="o">=</span> <span class="n">kernel_size</span> <span class="o">//</span> <span class="mi">2</span>
        <span class="n">self</span><span class="p">.</span><span class="n">score</span> <span class="o">=</span> <span class="n">nn</span><span class="p">.</span><span class="nc">Conv2d</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="n">kernel_size</span><span class="p">,</span> <span class="n">padding</span><span class="o">=</span><span class="n">padding</span><span class="p">,</span> <span class="n">bias</span><span class="o">=</span><span class="bp">False</span>
        <span class="p">)</span>

    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="n">self</span><span class="p">,</span> <span class="n">features</span><span class="p">):</span>
        <span class="n">average</span> <span class="o">=</span> <span class="n">features</span><span class="p">.</span><span class="nf">mean</span><span class="p">(</span><span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">keepdim</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
        <span class="n">maximum</span><span class="p">,</span> <span class="n">_</span> <span class="o">=</span> <span class="n">features</span><span class="p">.</span><span class="nf">max</span><span class="p">(</span><span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">keepdim</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
        <span class="n">summary</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="nf">cat</span><span class="p">([</span><span class="n">average</span><span class="p">,</span> <span class="n">maximum</span><span class="p">],</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
        <span class="n">attention</span> <span class="o">=</span> <span class="n">torch</span><span class="p">.</span><span class="nf">sigmoid</span><span class="p">(</span><span class="n">self</span><span class="p">.</span><span class="nf">score</span><span class="p">(</span><span class="n">summary</span><span class="p">))</span>
        <span class="n">focused</span> <span class="o">=</span> <span class="n">features</span> <span class="o">*</span> <span class="n">attention</span>
        <span class="k">return</span> <span class="n">focused</span><span class="p">,</span> <span class="n">attention</span>
</code></pre></div></div>

<p>Buradaki <code class="language-plaintext highlighter-rouge">attention</code>, görselleştirilebilen bir ısı haritasıdır. Ancak parlak bir bölge görmek, modelin karar nedenini kesin olarak kanıtlamaz. Dikkat haritası açıklanabilirlik için yararlı bir ipucu olsa da nedensellik testi değildir.</p>

<h2 id="model-gerçekten-doğru-yere-mi-bakıyor">Model gerçekten doğru yere mi bakıyor?</h2>

<p>Sadece doğruluk ölçmek yeterli değildir. Dikkat haritası insan tarafından işaretlenmiş nesne maskesiyle karşılaştırılabilir. Eşiklenmiş dikkat alanı $A$, gerçek bölge $G$ ise kesişim-birleşim oranı şöyledir:</p>

\[IoU = \frac{\vert A \cap G\vert }{\vert A \cup G\vert }\]

<p>Ayrıca görüntünün en dikkatli kısmını kapatıp tahmin güveninin düşüp düşmediği incelenebilir. Güven belirgin biçimde azalıyorsa model gerçekten o bölgeden yararlanıyor olabilir. Tersine, nesne yerine filigrana odaklanan bir ağ veri kümesindeki kestirme yolları öğrenmiş demektir.</p>

<p>Yönlendirilmiş dikkat; tıbbi görüntüleme, otonom sürüş, nesne takibi ve görsel soru cevaplama gibi alanlarda modelin enerjisini doğru yere toplar. Kısacası mesele daha fazla piksel görmek değil, hangi pikselin neden önemli olduğunu öğrenmektir.</p>

<p><img src="/img/yonlendirilmis-dikkat-sinir-45.svg" alt="yonlendirilmis-dikkat-sinir-45" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="yapay zeka" /><category term="bilgisayarlı görü" /><category term="derin öğrenme" /><category term="dikkat mekanizması" /><category term="pytorch" /><category term="sinir ağları" /><summary type="html"><![CDATA[Bir fotoğrafta kedi ararken duvardaki çatlakları, masanın desenini veya perde kıvrımlarını uzun uzun incelemeyiz; gözümüz hızla kulak, göz ve pati gibi ayırt edici bölgelere yönelir. Yönlendirilmiş dikkat (targeted attention), sinir ağlarına benzer bir seçicilik kazandırır. Model bütün pikselleri eşit derecede önemli kabul etmek yerine, yaptığı görev açısından anlamlı bölgelere daha yüksek ağırlık verir. Böylece hem tahminler iyileşebilir hem de ağın kararını nereden çıkardığı daha anlaşılır hâle gelebilir.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/yonlendirilmis-dikkat-sinir-45.png" /><media:content medium="image" url="https://program.sonsuz.us/img/yonlendirilmis-dikkat-sinir-45.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Zaman Serilerinde LSTM mi, TCN mi? Tekrarlayan Hafıza ile Paralel Evrişimin Düellosu</title><link href="https://program.sonsuz.us/posts/zaman-serilerinde-lstm-mi-tcn-mi-tekrarlayan-hafiza-ile-paralel-evrisimin-duellosu/" rel="alternate" type="text/html" title="Zaman Serilerinde LSTM mi, TCN mi? Tekrarlayan Hafıza ile Paralel Evrişimin Düellosu" /><published>2026-09-26T00:00:00+00:00</published><updated>2026-09-26T00:00:00+00:00</updated><id>https://program.sonsuz.us/posts/zaman-serilerinde-lstm-mi-tcn-mi-tekrarlayan-hafiza-ile-paralel-evrisimin-duellosu</id><content type="html" xml:base="https://program.sonsuz.us/posts/zaman-serilerinde-lstm-mi-tcn-mi-tekrarlayan-hafiza-ile-paralel-evrisimin-duellosu/"><![CDATA[<p>Zaman serisi modellemek, geçmişteki ipuçlarına bakarak geleceği tahmin etmeye benzer. LSTM bu işi adım adım ilerleyen güçlü bir hafızayla yaparken Temporal Convolutional Network (TCN), zaman eksenine geniş bir evrişim penceresinden bakar. Peki üretim hattındaki sensör verileri, finansal fiyatlar veya trafik yoğunluğu için hangisini seçmeliyiz? Cevap yalnızca doğrulukta değil; veri uzunluğu, eğitim süresi ve donanım kullanımında saklıdır.
``</p>

<h2 id="lstm-geçmişi-taşıyan-zincir">LSTM: Geçmişi taşıyan zincir</h2>

<p>LSTM, klasik RNN’lerde görülen gradyan kaybolması sorununu kapılarla azaltır. Her zaman adımında unutma, giriş ve çıkış kapıları hangi bilginin korunacağına karar verir. Basitleştirilmiş hücre güncellemesi şöyledir:</p>

\[c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t\]

<p>Burada $f_t$ unutma kapısı, $i_t$ giriş kapısı ve $c_t$ hücre belleğidir. Bu yapı uzun vadeli ilişkileri öğrenebilir; ancak $t$ anındaki hesaplama $t-1$ sonucuna bağlıdır. Dolayısıyla zaman adımları aynı anda işlenemez. Binlerce ölçüm içeren dizilerde GPU güçlü olsa bile model sırayla yürümek zorundadır: yetenekli ama her basamağa tek tek çıkan bir merdiven yolcusu gibi.</p>

<p>LSTM’nin gizli durumu aynı zamanda sabit boyutlu bir bilgi darboğazıdır. Çok uzun dizilerde geçmişteki ayrıntılar sıkışabilir. Buna karşılık değişken uzunluklu diziler ve adım adım çalışan çevrim içi sistemler için doğal bir çözümdür.</p>

<h2 id="tcn-evrişimle-zamanda-sıçramak">TCN: Evrişimle zamanda sıçramak</h2>

<p>TCN; nedensel, genişletilmiş ve çoğunlukla artık bağlantılı 1B evrişimlerden oluşur. <strong>Nedensel evrişim</strong>, modelin geleceği görmesini engeller. <strong>Genişletme (dilation)</strong> ise filtrenin ardışık noktalar yerine aralıklı örneklere ulaşmasını sağlar. Genişletme oranları $1, 2, 4, 8$ biçiminde artırıldığında alıcı alan hızla büyür.</p>

<p>Çekirdek boyutu $k$, katman sayısı $L$ ve iki katına çıkan genişletmeler için yaklaşık alıcı alan:</p>

\[R = 1 + (k-1)(2^L-1)\]

<p>Örneğin $k=3$ ve $L=6$ olduğunda model 127 zaman noktasını görebilir. Üstelik her konumdaki evrişim bağımsız hesaplanabildiğinden eğitim paralelleştirilebilir. Artık bağlantılar da derin ağlarda gradyan akışını kolaylaştırır.</p>

<table>
  <thead>
    <tr>
      <th>Özellik</th>
      <th>LSTM</th>
      <th>TCN</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Hesaplama</td>
      <td>Zaman boyunca sıralı</td>
      <td>Büyük ölçüde paralel</td>
    </tr>
    <tr>
      <td>Uzun bağımlılıklar</td>
      <td>Kapılı bellekle</td>
      <td>Geniş alıcı alanla</td>
    </tr>
    <tr>
      <td>Eğitim hızı</td>
      <td>Uzun dizilerde yavaş</td>
      <td>GPU’da genellikle hızlı</td>
    </tr>
    <tr>
      <td>Çevrim içi kullanım</td>
      <td>Doğal ve durum saklayabilir</td>
      <td>Girdi tamponu gerektirir</td>
    </tr>
    <tr>
      <td>Yorumlanacak ayar</td>
      <td>Gizli durum boyutu</td>
      <td>Çekirdek, katman, dilation</td>
    </tr>
    <tr>
      <td>Bellek kullanımı</td>
      <td>Durum ve aktivasyonlar</td>
      <td>Katman aktivasyonları</td>
    </tr>
  </tbody>
</table>

<h2 id="pytorch-ile-küçük-bir-tcn-bloğu">PyTorch ile küçük bir TCN bloğu</h2>

<p>Aşağıdaki blok, geleceğe ait değerleri kullanmamak için evrişim sonucunun sağ tarafını kırpar. Artık bağlantı ise girdiyi çıktıya ekleyerek eğitimi dengeler:</p>

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

<span class="k">class</span> <span class="nc">TCNBlock</span><span class="p">(</span><span class="n">nn</span><span class="p">.</span><span class="n">Module</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">channels</span><span class="p">,</span> <span class="n">kernel_size</span><span class="p">,</span> <span class="n">dilation</span><span class="p">):</span>
        <span class="nf">super</span><span class="p">().</span><span class="nf">__init__</span><span class="p">()</span>
        <span class="n">padding</span> <span class="o">=</span> <span class="p">(</span><span class="n">kernel_size</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">*</span> <span class="n">dilation</span>
        <span class="n">self</span><span class="p">.</span><span class="n">padding</span> <span class="o">=</span> <span class="n">padding</span>
        <span class="n">self</span><span class="p">.</span><span class="n">conv</span> <span class="o">=</span> <span class="n">nn</span><span class="p">.</span><span class="nc">Conv1d</span><span class="p">(</span>
            <span class="n">channels</span><span class="p">,</span> <span class="n">channels</span><span class="p">,</span> <span class="n">kernel_size</span><span class="p">,</span>
            <span class="n">padding</span><span class="o">=</span><span class="n">padding</span><span class="p">,</span> <span class="n">dilation</span><span class="o">=</span><span class="n">dilation</span>
        <span class="p">)</span>
        <span class="n">self</span><span class="p">.</span><span class="n">activation</span> <span class="o">=</span> <span class="n">nn</span><span class="p">.</span><span class="nc">ReLU</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="n">self</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
        <span class="n">y</span> <span class="o">=</span> <span class="n">self</span><span class="p">.</span><span class="nf">conv</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">self</span><span class="p">.</span><span class="n">padding</span><span class="p">:</span>
            <span class="n">y</span> <span class="o">=</span> <span class="n">y</span><span class="p">[:,</span> <span class="p">:,</span> <span class="p">:</span><span class="o">-</span><span class="n">self</span><span class="p">.</span><span class="n">padding</span><span class="p">]</span>
        <span class="k">return</span> <span class="n">self</span><span class="p">.</span><span class="nf">activation</span><span class="p">(</span><span class="n">y</span> <span class="o">+</span> <span class="n">x</span><span class="p">)</span>
</code></pre></div></div>

<p>Girdi biçimi <code class="language-plaintext highlighter-rouge">(parti, kanal, zaman)</code> olmalıdır. Birden fazla blok kurarken dilation değerlerini <code class="language-plaintext highlighter-rouge">1, 2, 4, 8</code> şeklinde artırmak, modelin kısa ve uzun örüntüleri birlikte yakalamasını sağlar.</p>

<h2 id="hangisini-seçmeli">Hangisini seçmeli?</h2>

<p>Diziler kısa, veri miktarı sınırlı veya sistem her yeni ölçümle gizli durumunu güncelleyecekse LSTM hâlâ güçlü bir başlangıçtır. Çok uzun diziler, büyük mini-batch’ler ve hızlı eğitim hedefleniyorsa TCN çoğu zaman daha verimli olur. Yine de kazananı mimarinin şöhreti değil, zaman sırasını bozmayan doğrulama belirlemelidir. Modelleri aynı parametre bütçesiyle; MAE, RMSE ve gecikme üzerinden karşılaştırın. Kısacası LSTM geçmişi cebinde taşır, TCN ise geçmişe geniş açılı bir objektifle bakar.</p>

<p><img src="/img/zaman-serilerinde-lstm-42.svg" alt="zaman-serilerinde-lstm-42" /></p>]]></content><author><name>Sonsuz Us</name></author><category term="Bilgi" /><category term="lstm" /><category term="tcn" /><category term="zaman serileri" /><category term="derin öğrenme" /><category term="pytorch" /><category term="yapay zeka" /><summary type="html"><![CDATA[Zaman serisi modellemek, geçmişteki ipuçlarına bakarak geleceği tahmin etmeye benzer. LSTM bu işi adım adım ilerleyen güçlü bir hafızayla yaparken Temporal Convolutional Network (TCN), zaman eksenine geniş bir evrişim penceresinden bakar. Peki üretim hattındaki sensör verileri, finansal fiyatlar veya trafik yoğunluğu için hangisini seçmeliyiz? Cevap yalnızca doğrulukta değil; veri uzunluğu, eğitim süresi ve donanım kullanımında saklıdır.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://program.sonsuz.us/img/zaman-serilerinde-lstm-42.png" /><media:content medium="image" url="https://program.sonsuz.us/img/zaman-serilerinde-lstm-42.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry></feed>