<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Eren ALTUN on Medium]]></title>
        <description><![CDATA[Stories by Eren ALTUN on Medium]]></description>
        <link>https://medium.com/@eren.alltun?source=rss-a95e2cc08f44------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*DjPMElxLiBpZsA_VFCjRYQ.jpeg</url>
            <title>Stories by Eren ALTUN on Medium</title>
            <link>https://medium.com/@eren.alltun?source=rss-a95e2cc08f44------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 09:49:28 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@eren.alltun/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Bilimsel PDF Anlama (KIRPIT)]]></title>
            <link>https://medium.com/@eren.alltun/bilimsel-pdf-anlama-9578914b30c9?source=rss-a95e2cc08f44------2</link>
            <guid isPermaLink="false">https://medium.com/p/9578914b30c9</guid>
            <dc:creator><![CDATA[Eren ALTUN]]></dc:creator>
            <pubDate>Thu, 12 Nov 2026 07:26:48 GMT</pubDate>
            <atom:updated>2026-11-12T16:31:52.664Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Bilimsel makalelerdeki tablo, formül ve grafikleri otomatik çıkaran bir araç yaptım. En önemli özelliği, neyi yapıp neyi yapmadığını açıkça söylemesi.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n4FJq6YDXs1CmMDjSl-yug.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FMxxJ_jiK2HvtH-Hs10nZA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_MXzlkRi1cYOXiRomdsp5w.png" /></figure><h3>Sorun: PDF’te bilgi metinde değil, görsellerde saklı</h3><p>Bilimsel makalelerde bulgular çoğu zaman paragraflarda değil; tablolarda, denklemlerde ve grafiklerde yer alır. PDF’i düz metne çevirdiğinizde hücrelerin hangi sütuna ait olduğu, formüldeki indisler ya da grafikteki eksen-seri ilişkisi kolayca kaybolur.</p><p>Bütün PDF’i bir görsel dil modeline (VLM) verip “şunu çıkar” demek de çözüm değil. Model hedef öğeyi bulamayabilir, çıktı düzensiz gelebilir, sonucu kaynak sayfayla eşleştirmek zorlaşır.</p><h3>Yaklaşım: Önce bul, sonra oku</h3><p>Projenin temel fikri, belge ayrıştırmayı ve görsel yorumlamayı birbirinden ayırmak:</p><ol><li><strong>Docling</strong> PDF’in yapısını çıkarır ve tablo, formül, figürlerin sayfa ve konumunu bulur.</li><li><strong>PyMuPDF</strong> bu konumlardan PNG kırpıntıları üretir.</li><li>Her kırpıntı, türüne özel bir istemle VLM’e (Gemini veya yerel Ollama) gönderilir.</li><li>Sonuç, <strong>kaynak kırpıntısıyla yan yana</strong> Streamlit arayüzünde gösterilir.</li></ol><p>Model bütün sayfayı değil, yalnızca ilgili alanı görür. Her tür için çıktı da farklıdır:</p><ul><li><strong>Tablo:</strong> Markdown veya HTML, istenirse CSV</li><li><strong>Formül:</strong> LaTeX</li><li><strong>Figür:</strong> Türü, eksenleri ve ana sonucu anlatan kısa Türkçe açıklama</li></ul><h3>Araç neyi kontrol ediyor?</h3><p>Kontroller iki katmanda çalışıyor.</p><p><strong>1. Öğe düzeyinde: Doğru yeri buldu mu?</strong></p><ul><li>Makalede kaç tablo, formül ve figür tespit edildi?</li><li>Formülün başlangıç ve bitiş noktaları doğru mu?</li></ul><p>Bu adım önemli, çünkü kırpıntı yanlış ya da dar olursa model doğru bölgeyi hiç göremez.</p><p><strong>2. Biçimsel düzeyde: Çıktı düzgün görünüyor mu?</strong></p><ul><li>Tabloda tüm satırların sütun sayısı eşit mi?</li><li>LaTeX’te parantezler dengeli mi, \begin / \end eşleşiyor mu?</li><li>Figür açıklaması çok kısa mı, görsel logo ya da boş alan mı?</li></ul><p>Bir hata çıkarsa model, uyarı geri bildirimiyle bir kez daha denenir.</p><h3>Neyi kontrol etmiyor?</h3><p>Hiçbir katman, modelin <strong>hücre değerlerini, sembolleri ve yorumları doğru okuyup okumadığını</strong> kontrol etmez.</p><p>Bir VLM tabloda 0.85 değerini 0.65 diye okuyabilir. Sütun sayısı yine tutar, kontrol geçer, hata fark edilmez. İndisi atlanmış ama parantezleri dengeli bir LaTeX formülü de kontrollerden temiz çıkar. Uzun ve akıcı bir figür açıklaması da bilimsel olarak doğru olduğunu kanıtlamaz.</p><p>Yani “doğru öğeyi buldum” demek, “doğru okudum” demek değildir. Tabiki projenin ileriki aşamalarında girilen değerler ile çıktılar eşleşecek şekilde kontrolü eklenmesi planlanmaktadır.</p><h3>Doğrulayan kişi sensin</h3><p>Bu yüzden sistemin tasarımı <strong>insan denetimine</strong> dayanıyor. Çıktı ile kaynak kırpıntısı yan yana durduğu için hatalı okumayı fark etmek kolay. Ama o karşılaştırmayı yapan sistem değil, kullanıcı.</p><ul><li>Yayınlayacağın bir tabloyu mutlaka orijinal makaleyle karşılaştır.</li><li>Formülü LaTeX’e aldıktan sonra derleyip kaynakla kontrol et.</li><li>Figür açıklamasını nihai yorum değil, taslak olarak gör.</li></ul><h3>Günlük kullanımı kolaylaştıran detaylar</h3><ul><li>Tüm PDF’i ya da yalnızca belirli sayfaları ve öğe türlerini işleyebilirsin. Bu hem zamandan hem API maliyetinden tasarruf sağlar.</li><li>Docling çıktıları ve model yanıtları önbelleğe alınır, aynı iş tekrar yapılmaz.</li><li>Her öğe ayrı işlenir, bir hata bütün belgeyi bozmaz.</li><li>Sonuçlar result.json, equations.tex, tablo dosyaları ve okuma sırasına göre birleştirilmiş bir Markdown olarak dışa aktarılır.</li><li>Streamlit arayüzünün yanında toplu işlem için komut satırı da var.</li></ul><h3>Bilmen gereken diğer sınırlar</h3><ul><li>Karmaşık tablolar, sayfalar arası devam eden tablolar, çift sütunlu düzenler ve taranmış PDF’ler sonucu kötü etkileyebilir.</li><li>Gemini gibi harici bir sağlayıcı seçersen kırpıntılar o sağlayıcıya gönderilir. Hassas veya yayımlanmamış belgelerde bunu düşün. Yerel Ollama bir alternatif.</li></ul><h3>Kapanış</h3><p>Bu proje “PDF’i yapay zekâya ver, doğru sonucu al” vaadi sunmuyor. Sunduğu şey daha mütevazı ama dürüst: bilimsel PDF’lerdeki görsel içeriği bulma, aktarma ve <strong>incelenebilir</strong> hâle getirme sürecini düzenlemek.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9578914b30c9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LLM’ler Neyle Beslenir? Ham İnternet Verisinden Model Eğitimine Veri İşleme Rehberi]]></title>
            <link>https://medium.com/@eren.alltun/llmler-neyle-beslenir-ham-i%CC%87nternet-verisinden-model-e%C4%9Fitimine-veri-i%CC%87%C5%9Fleme-rehberi-6a3c89344683?source=rss-a95e2cc08f44------2</link>
            <guid isPermaLink="false">https://medium.com/p/6a3c89344683</guid>
            <dc:creator><![CDATA[Eren ALTUN]]></dc:creator>
            <pubDate>Tue, 10 Nov 2026 16:13:00 GMT</pubDate>
            <atom:updated>2026-11-10T16:13:00.609Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Bir dil modelinin zekâsı, mimarisinden önce verisinden gelir. Terabaytlarca dağınık metnin, eğitime hazır trilyonlarca token’a nasıl dönüştüğünün hikâyesi.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aAnGq6ex9dQxvHRZ0UuA_Q.jpeg" /></figure><h3>Giriş: Model Değil, Veri Konuşuyor</h3><p>LLM dünyasında konuşmalar genellikle parametre sayısı, mimari yenilikler ve GPU kümeleri etrafında döner. Oysa sahada çalışan herkesin bildiği bir gerçek var: <strong>aynı mimariyi iki farklı veri setiyle eğittiğinizde ortaya çıkan iki model birbirinden çok farklı olabilir.</strong> “Garbage in, garbage out” ilkesi, LLM’lerde her zamankinden daha geçerli.</p><p>İnternet; harika makalelerin, ders notlarının ve kaliteli kodun yanı sıra spam sayfaların, tekrar eden şablon metinlerin, bozuk kodlanmış karakterlerin, kişisel bilgilerin ve nefret söyleminin de bulunduğu devasa bir çöplük. Bu ham veriyi doğrudan modele vermek, bir öğrenciyi sadece çöp kutusundan topladığı kâğıtlarla eğitmeye benzer.</p><p>Bu yazıda ham verinin model eğitimine giden yolculuğunu uçtan uca inceleyeceğiz:</p><ol><li>Veri toplama</li><li>Temizleme ve filtreleme</li><li>Tokenization</li><li>Pipeline: sharding, karıştırma ve örnekleme</li><li>Veri augmentasyonu ve sentetik veri</li><li>Tüm aşamalara eşlik eden etik ve güvenlik katmanı</li></ol><p>Büyüklükleri kafanızda canlandırmak için kabaca bir çerçeve: Modern bir LLM’in ön eğitim verisi <strong>onlarca terabaytlık ham metinle</strong> başlar, temizleme sonrasında bunun <strong>önemli bir bölümü (çoğu zaman %30–60 gibi büyük bir oran) elenir</strong> ve geriye kalan veri, güncel açık modellerde <strong>trilyonlarca token</strong> düzeyine ulaşır. Örneğin Llama 3 ailesi 15 trilyondan fazla token ile eğitildi. Bu rakamlar projeden projeye çok değişir. Önemli olan büyüklük düzeni.</p><h3>Aşama 1: Veri Toplama — Metin Nereden Geliyor?</h3><p>Bir LLM’in veri karışımı genellikle dört geniş kaynak ailesinden oluşur. Her birinin kendine özgü güçlü ve zayıf yanları var.</p><h3>1.1 Web taraması (Web Scraping)</h3><p>En büyük hacim buradan gelir. <strong>Common Crawl</strong>, aylık olarak yayımlanan ve toplamda petabayt ölçeğine ulaşan açık bir web arşividir. Ancak Common Crawl’ın ham çıktısı HTML’dir ve modelin işine yaramaz. Süreç kabaca şöyle işler:</p><ul><li><strong>HTML’den metin çıkarma:</strong> Menüler, reklamlar, çerez bildirimleri, JavaScript ve CSS ayıklanır, yalnızca ana içerik tutulur. (Burada kullanılan çıkarıcının kalitesi bile sonucu belirgin biçimde etkiler.)</li><li><strong>Dil tespiti:</strong> fastText tabanlı dil sınıflandırıcıları (ya da langid gibi araçlar) ile her doküman hangi dilde olduğuna göre etiketlenir.</li><li><strong>Ön filtreleme:</strong> Çok kısa, çok uzun veya anlamsız dokümanlar henüz bu aşamada atılır.</li></ul><p>Bu yaklaşımın bilinen örnekleri arasında <strong>C4</strong> (T5 için hazırlanan temizlenmiş Common Crawl alt kümesi), <strong>CCNet</strong>, <strong>RefinedWeb</strong>, <strong>FineWeb</strong> ve <strong>Dolma</strong> gibi açık veri setleri var. Bunlar aynı zamanda “ham web’den nasıl iyi bir eğitim verisi çıkarılır” sorusunun belgelenmiş cevapları olarak da okunabilir.</p><h3>1.2 Kitap ve akademik külliyatlar</h3><p>Web’e kıyasla daha az hacimli ama çok daha yüksek kaliteli bir kaynak: <strong>Project Gutenberg</strong> (kitaplar), <strong>arXiv</strong> (akademik makaleler), <strong>Wikipedia</strong> (ansiklopedik bilgi), hukuk ve tıp metinleri. Bu kaynakların değeri, uzun bağlam boyunca tutarlı anlatım, doğru dil bilgisi ve yoğun bilgi içermeleridir. Modelin uzun metinleri takip etme yeteneği büyük ölçüde bu tür veriden beslenir.</p><h3>1.3 Sosyal medya ve forumlar</h3><p><strong>Reddit</strong> tartışmaları, <strong>Stack Exchange</strong> soru-cevapları, kısa gönderiler… Günlük konuşma dilini, diyalog yapısını ve gerçek kullanıcıların gerçek sorularını yakalamanın en iyi yolu bu kaynaklardır. Teknik Q&amp;A siteleri ayrıca “soru sor, cevap al” formatını modele doğal biçimde öğretir. Bedeli ise gürültü, kişisel veri riski ve toksik içerik oranının yüksekliğidir.</p><h3>1.4 Sentez ve uzman verileri</h3><p>Belirli görevler için özel olarak üretilmiş veriler:</p><ul><li>Başka bir güçlü model tarafından üretilmiş <strong>sentetik veri</strong></li><li>İnsan etiketleyicilerin hazırladığı <strong>talimat (instruction) veri setleri</strong></li><li>RLHF ve benzeri yöntemler için <strong>tercih verileri</strong> (aynı soruya verilen iki cevaptan hangisinin daha iyi olduğu)</li><li>Çeviri külliyatları</li></ul><p>Bu veri küçüktür ama modelin “asistan gibi davranmasını” sağlayan asıl katmandır.</p><blockquote><strong><em>Not:</em></strong><em> Hangi kaynağın eğitimde kullanılabileceği hukuki olarak da tartışmalı bir alan. Telif hakkı, lisans ve izin meselelerine yazının sonundaki etik bölümde döneceğiz.</em></blockquote><h3>Aşama 2: Veri Temizleme — Çöpten Altın Çıkarmak</h3><p>Toplama aşamasından çıkan veri hâlâ çok kirli. Temizleme, hem emek yoğun hem de model kalitesine en doğrudan etki eden aşama. Üç ana başlığı var: filtreleme, normalizasyon ve deduplikasyon.</p><h3>2.1 Düşük kaliteli içeriği filtrelemek</h3><p>Filtreleme iki katmanda çalışır.</p><p><strong>Kural tabanlı (heuristic) filtreler.</strong> Ucuz, hızlı ve şeffaf olduğu için ilk elemeyi bunlar yapar. Tipik örnekler (eşikler pipeline’a göre değişir, aşağıdakiler örnek değerlerdir):</p><ul><li><strong>Doküman/cümle uzunluğu:</strong> Ortalama kelime sayısı aşırı düşük ya da aşırı yüksek olan dokümanlar elenir (örneğin cümle başına 3&#39;ten az veya 1000&#39;den fazla kelime).</li><li><strong>Tekrar oranı:</strong> Aynı n-gram’ların veya satırların çok sık tekrarlandığı metinler (örneğin %30&#39;un üzerinde tekrar) büyük olasılıkla şablon ya da spam içeriktir.</li><li><strong>Dil olasılığı:</strong> Hedef dilde olma olasılığı düşük (örneğin 0.9&#39;un altında) dokümanlar atılır.</li><li><strong>Sembol ve noktalama oranları, “lorem ipsum” gibi bilinen kalıplar, aşırı kısa satırlar</strong> gibi başka sinyaller de kullanılır.</li></ul><p><strong>Model tabanlı filtreler.</strong> Kuralların yakalayamadığı “kalite” kavramını ölçmek için küçük modeller devreye girer:</p><ul><li><strong>Perplexity filtreleme:</strong> Wikipedia gibi temiz bir kaynakta eğitilmiş hafif bir dil modeli (CCNet’te KenLM kullanılır) metne ne kadar “şaşırdığını” ölçer. Çok yüksek perplexity genellikle bozuk, anlamsız veya olağandışı metne işaret eder. Dikkat: Perplexity, aşırı sade ya da çok teknik ama değerli metinleri de cezalandırabilir, bu yüzden tek başına kullanılması riskli.</li><li><strong>Kalite sınıflandırıcıları:</strong> “Kaliteli” kabul edilen örneklerle (örneğin Wikipedia’nın referans gösterdiği sayfalar) “sıradan” web örneklerini ayırt etmeyi öğrenen sınıflandırıcılar, her dokümana 0–1 arası bir kalite puanı verir. Son dönemde büyük bir LLM’in dokümanları “eğitici değeri” açısından puanlaması, ardından bu puanlarla küçük bir sınıflandırıcı eğitilip tüm veriye uygulanması yaygın bir yaklaşım hâline geldi (FineWeb-Edu bu fikrin tanınmış örneğidir).</li></ul><p><strong>Zararlı ve hassas içerik.</strong></p><ul><li><strong>PII (kişisel veri) filtreleri:</strong> E-posta, telefon, IP adresi, kimlik numarası gibi kalıplar regex ve NER tabanlı yöntemlerle bulunur.</li><li><strong>NSFW/toksiklik sınıflandırıcıları:</strong> Belirli bir skorun üzerindeki içerik elenir ya da ağırlığı düşürülür.</li></ul><p>Bu aşamanın zor kısmı “ne kadar agresif olunacağı” kararıdır. Çok sıkı filtreleme veriyi sterilleştirir, çeşitliliği ve az temsil edilen toplulukların dilini yok edebilir. Çok gevşek filtreleme ise gürültü ve zararlı içerik sızdırır.</p><h3>2.2 Normalizasyon</h3><p>Metinler modele girmeden önce tutarlı bir biçime getirilir:</p><ul><li><strong>Unicode normalizasyonu (NFKC):</strong> Aynı görünen ama farklı kodlanmış karakterler tek biçime indirgenir. Türkçe için özellikle önemli, çünkü İ/ı, ş, ğ gibi karakterlerin farklı kodlanmış biçimleri tokenizer&#39;da gereksiz çeşitlilik yaratır.</li><li><strong>Boşluk ve satır sonu temizliği:</strong> Gereksiz boşluklar, tekrar eden newline’lar kaldırılır.</li><li><strong>Büyük/küçük harf:</strong> Modern LLM’lerin çoğu büyük/küçük harfi korur (isim, kısaltma, kod ayrımı için bilgi taşıdığından), ancak bu tasarım kararı modele göre değişir.</li><li><strong>HTML entity dönüşümü:</strong> &amp;amp; gibi ifadeler &amp; karakterine çevrilir.</li><li><strong>URL ve emoji işleme:</strong> Özel token ya da placeholder ile temsil edilebilir, ya da olduğu gibi bırakılabilir.</li></ul><p>Dikkat edilmesi gereken bir ince nokta: Normalizasyon <em>geri döndürülemez</em> bir işlemdir. Kod, tablo veya biçimlendirme içeren verilerde agresif boşluk temizliği anlam kaybına yol açabilir.</p><h3>2.3 Deduplikasyon: Aynı Şeyi Bin Kere Okumak</h3><p>Web’de aynı içerik defalarca kopyalanır: haber ajansı metinleri, lisans metinleri, forum alıntıları, şablon sayfalar. Bunların temizlenmesi için dört seviye kullanılır:</p><ul><li><strong>Exact dedup:</strong> Dokümanların MD5/SHA256 gibi hash’leri karşılaştırılır; birebir aynı olanlardan biri tutulur.</li><li><strong>Near-dedup:</strong> Neredeyse aynı dokümanlar (birkaç kelimesi farklı olanlar) <strong>MinHash + LSH (Locality-Sensitive Hashing)</strong> ile kümelenir. Her doküman n-gram kümesi olarak düşünülür, MinHash imzaları ile Jaccard benzerliği hızlıca tahmin edilir.</li><li><strong>Line/paragraf düzeyinde dedup:</strong> Dokümanlar farklı olsa da içlerinde tekrar eden satırlar (çerez uyarıları, alt bilgi metinleri) temizlenir.</li><li><strong>Cross-dataset dedup:</strong> Farklı veri setleri arasındaki kopyalar bulunur. Özellikle <strong>değerlendirme (benchmark) verisinin eğitim setine sızmasını</strong> (contamination) önlemek için kritik.</li></ul><p>Küçük bir MinHash örneği (datasketch kütüphanesi ile):</p><pre>from datasketch import MinHash, MinHashLSH<br><br>def minhash_of(text, num_perm=128):<br>    m = MinHash(num_perm=num_perm)<br>    # Basit kelime 3&#39;lüleri (shingle)<br>    words = text.lower().split()<br>    for i in range(len(words) - 2):<br>        m.update(&quot; &quot;.join(words[i:i+3]).encode(&quot;utf-8&quot;))<br>    return m<br><br>lsh = MinHashLSH(threshold=0.8, num_perm=128)<br><br>docs = {<br>    &quot;a&quot;: &quot;LLM&#39;lerin başarısı büyük ölçüde eğitim verisinin kalitesine bağlıdır&quot;,<br>    &quot;b&quot;: &quot;LLM&#39;lerin başarısı büyük ölçüde eğitim verisinin kalitesine bağlıdır.&quot;,<br>    &quot;c&quot;: &quot;Tokenization metni sayısal kimliklere dönüştürür&quot;,<br>}<br><br>for key, text in docs.items():<br>    mh = minhash_of(text)<br>    if not lsh.query(mh):      # benzeri yoksa ekle<br>        lsh.insert(key, mh)<br>        print(f&quot;{key}: tutuldu&quot;)<br>    else:<br>        print(f&quot;{key}: kopya olarak elendi&quot;)</pre><p>Peki neden bu kadar önemli? Çünkü tekrar eden veri modelin <strong>ezberlemesine</strong> yol açar. Bu da hem genelleme yeteneğini düşürür hem de eğitim verisinin birebir sızdırılması riskini artırır. Araştırmalar, deduplikasyonun hem eğitim verimliliğini hem de model kalitesini iyileştirdiğini gösteriyor.</p><h3>Aşama 3: Tokenization — Metni Sayılara Çevirmek</h3><p>Sinir ağları harflerle değil sayılarla çalışır. Tokenization, temizlenmiş metni <strong>token ID</strong>’lerine dönüştürür. Her token, modelin sabit <strong>kelime dağarcığının (vocabulary)</strong> bir elemanıdır. Bir token bazen bir kelime, bazen kelimenin bir parçası, bazen tek bir karakter ya da noktalama işaretidir.</p><h3>3.1 Neden kelime değil alt-kelime?</h3><p>Kelime bazlı bir sözlük iki sorun yaratır: sözlük devasa olur ve görülmemiş kelimelerde (&lt;unk&gt;) bilgi kaybedilir. Karakter bazlı yaklaşım ise diziler çok uzar ve model verimsizleşir. <strong>Alt-kelime (subword) tokenization</strong> ikisinin arasında bir denge kurar: sık geçen kelimeler tek token olur, nadir kelimeler anlamlı parçalara bölünür.</p><h3>3.2 BPE (Byte-Pair Encoding)</h3><p>GPT ve Llama gibi modellerde kullanılan en yaygın algoritma BPE’dir. Mantığı şöyle:</p><ol><li>En küçük birimlerle (karakterler ya da baytlar) başla.</li><li>Korpusta en sık yan yana gelen ikiliyi bul ve yeni bir token olarak birleştir.</li><li>Hedef sözlük boyutuna ulaşana kadar tekrarla.</li></ol><p><strong>Byte-level BPE</strong> varyantı baytlardan başladığı için hiçbir karakter “bilinmeyen” olmaz. Hiç görmediği bir emojiyi ya da alfabeyi bile bayt dizisi olarak temsil edebilir. Sözlük boyutları modele göre değişir: GPT-4&#39;ün kullandığı cl100k_base yaklaşık 100 bin, Llama 3&#39;ün tokenizer&#39;ı yaklaşık 128 bin token içerir. Daha büyük sözlük, aynı metni daha az token ile ifade etmeyi sağlar. Ancak embedding ve çıkış katmanlarını büyüttüğü için bir maliyeti de vardır.</p><p>Tokenizer’ın gerçekte ne yaptığını görmek için tiktoken ile hızlı bir deney:</p><pre>import tiktoken<br><br>enc = tiktoken.get_encoding(&quot;cl100k_base&quot;)<br><br>for text in [&quot;Hello world&quot;, &quot;Merhaba dünya&quot;, &quot;Evlerinizdekilerden&quot;]:<br>    ids = enc.encode(text)<br>    parts = [enc.decode([i]) for i in ids]<br>    print(f&quot;{text!r} -&gt; {len(ids)} token: {parts}&quot;)</pre><p>Bu küçük deneyi kendi cümlelerinizle çalıştırmanızı öneririm. Özellikle uzun, eklerle dolu Türkçe kelimelerin nasıl parçalandığı oldukça öğretici.</p><h3>3.3 Türkçe ve “token vergisi”</h3><p>İngilizce için yaygın kaba kural şudur: <strong>1 token ≈ 4 karakter ≈ 0.75 kelime.</strong> Peki Türkçe?</p><p>Türkçe <strong>eklemeli (agglutinative)</strong> bir dil. Tek bir kelime, köke eklenen yapım ve çekim ekleriyle bütün bir cümlenin anlamını taşıyabilir (“Evlerinizdekilerden” gibi). İngilizce ağırlıklı verilerle eğitilmiş bir tokenizer bu kelimeleri çok sayıda küçük parçaya böler. Sonuç olarak Türkçe bir metin, aynı anlamdaki İngilizce metne göre genellikle <strong>daha fazla token</strong> tutar. Kaba bir ifadeyle Türkçede 1 token kabaca 0.5–0.6 kelimeye denk gelebilir, ancak oran tokenizer’a ve metin türüne göre belirgin biçimde değişir.</p><p>Bunun pratik sonuçları var:</p><ul><li>Aynı bağlam penceresine daha az Türkçe metin sığar.</li><li>API tabanlı kullanımda aynı içerik için daha fazla token, dolayısıyla daha yüksek maliyet ödenir.</li><li>Model, Türkçe örnekler için daha fazla “adım” harcar. Bu da eğitim ve çıkarım verimliliğini etkiler.</li></ul><p>Bu nedenle çok dilli ya da Türkçe odaklı modellerde tokenizer’ı eğitirken Türkçe verinin yeterli oranda bulunması en az model mimarisi kadar kritik bir karardır.</p><h3>3.4 Özel (special) token’lar</h3><p>Modeller metnin yapısını belirtmek için özel token’lar kullanır. Tam adlar modelden modele değişir, ancak işlevleri benzerdir:</p><ul><li><strong>Metin başlangıcı / sonu</strong> (örneğin &lt;|begin_of_text|&gt;, &lt;|end_of_text|&gt;): Doküman sınırlarını belirtir.</li><li><strong>Dolgu token’ı</strong> (&lt;|pad|&gt;): Batch içinde farklı uzunluktaki dizileri eşitlemek için kullanılır.</li><li><strong>Bilinmeyen token</strong> (&lt;|unk|&gt;): Sözlükte karşılığı olmayan girdiler için. Byte-level BPE&#39;de pratikte nadiren gerekir.</li><li><strong>Sohbet formatı token’ları</strong> (örneğin &lt;|im_start|&gt;, &lt;|im_end|&gt;): Kimin konuştuğunu (sistem, kullanıcı, asistan) modele bildirir.</li></ul><p>Chat modellerinde bu token’lar bir <strong>chat template</strong> içinde bir araya gelir. Eğitim verisindeki formatla çıkarım sırasında kullanılan format uyuşmazsa, model beklenmedik biçimde kötü davranabilir. Bu, sahada sık yapılan hatalardan biridir.</p><h3>Aşama 4: Veri Pipeline — Eğitime Giden Boru Hattı</h3><p>İşlenmiş verinin model eğitimine akması için bütün aşamaların otomatik, tekrarlanabilir ve ölçeklenebilir bir <strong>pipeline</strong> olarak çalışması gerekir:</p><pre>Veri toplama → Temizleme → Deduplikasyon → Tokenization → Sharding → Training</pre><p>Bu zincirin son halkaları, eğitimin verimini doğrudan belirler.</p><h3>4.1 Sharding, karıştırma ve paketleme</h3><ul><li><strong>Sharding:</strong> Tokenize edilmiş veri, sabit boyutlu parçalara (shard) bölünür. Tipik olarak shard başına birkaç yüz MB ile birkaç GB arası boyutlar kullanılır. Böylece binlerce GPU’ya dağıtılmış okuma yapılabilir ve I/O verimli olur.</li><li><strong>Shuffle:</strong> Veri sırayla verilirse model, ardışık batch’lerde aynı kaynak türünü görüp dengesiz öğrenir. Bu yüzden shard’lar ve içindeki örnekler karıştırılır.</li><li><strong>Prefetching ve önbellekleme:</strong> Eğitim sırasında GPU’ların veri beklemediğinden emin olmak için sonraki batch’ler önceden hazırlanır.</li><li><strong>Sequence packing:</strong> Kısa dokümanlar, sabit uzunluktaki (örneğin 4K veya 8K token) eğitim dizilerini doldurmak için uç uca birleştirilir, aralarına doküman sonu token’ı konur. Böylece dolgu (padding) israfı azalır. Daha ileri uygulamalarda farklı dokümanların birbirine “dikkat etmemesi” için attention maskeleme de kullanılır.</li></ul><h3>4.2 Sampling stratejisi: Karışım oranları</h3><p>Farklı kaynaklardan gelen verinin <strong>oranı</strong>, modelin karakterini belirler. Aşağıdaki dağılım yalnızca fikir vermek için örnek bir karışımdır, gerçek oranlar her model için farklıdır ve çoğu zaman gizli tutulur:</p><ul><li>Web verisi: yaklaşık %60–70</li><li>Kitaplar: yaklaşık %15–20</li><li>Akademik içerik: yaklaşık %5–10</li><li>Sosyal medya ve forumlar: yaklaşık %5–10</li></ul><p>İlginç olan, <strong>kalite ağırlıklı örnekleme</strong> yapılabilmesi. Küçük ama yüksek kaliteli kaynaklar (Wikipedia, kitaplar) eğitim boyunca birden fazla kez (birden fazla epoch) görülürken, büyük ama gürültülü web verisi daha az tekrar edilebilir. Karışım oranları genellikle küçük ölçekli deneylerle ayarlanır ve çoğu zaman “veri karışımı ablation’ları” adı verilen çalışmalar yapılır.</p><h3>4.3 Veri pişirme (Data cooking)</h3><p>İleri düzey pipeline’larda veri tek geçişle işlenmez; birden çok kez, giderek daha akıllı yöntemlerle “pişirilir”:</p><ul><li><strong>Heuristic filtreleme:</strong> Regex, uzunluk, dil skoru gibi kurallara dayalı ilk eleme.</li><li><strong>Model tabanlı filtreleme:</strong> Küçük bir modelle perplexity ölçümü ya da kalite sınıflandırıcısı ile düşük kaliteli verinin elenmesi.</li><li><strong>Domain sınıflandırma:</strong> Her dokümanın hangi alana (kod, matematik, haber, hukuk vb.) ait olduğunun tespit edilmesi. Böylece karışım oranları alan bazında ayarlanabilir.</li><li><strong>Kalite skorlama:</strong> Her dokümana 0–1 arası kalite puanı verilmesi ve eğitim sonlarına doğru yalnızca yüksek puanlı verinin kullanıldığı bir “son aşama” (annealing) stratejisi uygulanması.</li></ul><p>Büyük ekipler bu aşamaları Spark, Ray gibi dağıtık işleme araçlarıyla ve <strong>DataTrove</strong> gibi açık kaynak veri hattı kütüphaneleriyle yönetiyor. Aslında kullanılan teknoloji kadar önemli olan, her adımın <strong>versiyonlanması ve izlenebilir</strong> olması.</p><h3>Aşama 5: Veri Augmentasyonu — Az Veriyi Çoğaltmak, Eksik Veriyi Üretmek</h3><p>Mevcut veri üzerinde dönüşümler uygulayarak ya da yeni veri üreterek hem miktar hem çeşitlilik artırılabilir. İki ana yaklaşım var.</p><h3>5.1 Klasik metin dönüşümleri</h3><ul><li><strong>Back-translation:</strong> Metni başka bir dile çevirip geri çevirmek. Anlamı koruyup ifadeyi değiştirir. Özellikle Türkçe gibi görece az kaynaklı dillerde değerli.</li><li><strong>Synonym replacement:</strong> Kelimelerin eş anlamlılarıyla değiştirilmesi.</li><li><strong>Noise ekleme:</strong> Rastgele yazım hatası, kelime silme veya yer değiştirme. Modeli gürültüye karşı dayanıklı hâle getirir.</li><li><strong>Paraphrasing:</strong> Aynı anlamı farklı cümlelerle ifade etmek.</li></ul><p>Bu yöntemler daha çok sınıflandırma ve ince ayar (fine-tuning) senaryolarında işe yarar. Trilyon token’lık ön eğitimde ise tek başına belirleyici olmaz.</p><h3>5.2 Model tabanlı augmentasyon ve sentetik veri</h3><p>Güçlü bir modelin başka bir model için veri ürettiği bu yaklaşım, son yıllarda en hızlı gelişen alan:</p><ul><li><strong>Instruction tuning verisi:</strong> Güçlü bir modelle “talimat → cevap” çiftleri üretmek.</li><li><strong>Self-Instruct:</strong> Modelin birkaç tohum örnekten yola çıkarak kendi talimatlarını ve cevaplarını üretmesi.</li><li><strong>Evol-Instruct:</strong> Basit talimatları adım adım karmaşıklaştırarak (kısıt ekleme, akıl yürütme derinliği artırma) daha zengin bir talimat seti oluşturmak.</li><li><strong>Tercih verisi (DPO/RLHF):</strong> Aynı soruya verilen birden fazla model cevabı arasından “iyi” ve “kötü” çiftleri seçerek tercih öğrenmeyi sağlayan veri hazırlamak.</li></ul><p>Sentetik verinin kendine özgü riskleri var: Üretici modelin hataları ve önyargıları yeni veriye taşınır, çeşitlilik düşebilir ve model kendi çıktısıyla tekrar tekrar eğitilirse kalite giderek bozulabilir (<strong>model collapse</strong> olarak anılan sorun). Bu yüzden sentetik veri de insan verisi gibi filtrelenmeli, doğrulanmalı ve gerçek veriyle dengeli karıştırılmalı.</p><h3>Tüm Aşamalarda Geçerli: Etik ve Güvenlik</h3><p>Buraya kadar anlattığımız aşamaların her biri teknik bir iş gibi görünüyor. Ama veri işleme <strong>aynı zamanda etik ve hukuki sorumluluk</strong> demek. Bu nedenle etik, pipeline’ın ayrı bir adımı değil, her aşamaya eşlik eden bir <strong>koruma katmanı (guardrail)</strong>.</p><h3>Gizlilik ve mevzuat</h3><ul><li><strong>PII taraması ve maskeleme:</strong> İsim, adres, e-posta, telefon, kimlik numarası (Türkiye için TC Kimlik No dahil) tespit edilip maskelenmeli ya da kaldırılmalı. Regex tek başına yetmez, bağlama duyarlı (NER tabanlı) yöntemlerle desteklenmeli.</li><li><strong>KVKK ve GDPR:</strong> Türkiye’de Kişisel Verilerin Korunması Kanunu (KVKK), Avrupa’da GDPR; kişisel verinin işlenmesine, silinmesini talep etme hakkına ve amaca uygun kullanıma ilişkin yükümlülükler getirir. Web’den toplanan verinin bu çerçevede nasıl ele alınacağı hâlâ hukuki tartışmaların konusu.</li><li><strong>Telif hakkı:</strong> Telifli içeriğin eğitimde kullanımının hukuki durumu ülkeden ülkeye değişiyor ve birçok davada henüz netleşmedi. “Fair use” gibi kavramlar her yerde geçerli değil. Bu konuda mutlaka hukuki danışmanlık alınmalı.</li></ul><h3>Önyargı ve temsil</h3><ul><li><strong>Demografik önyargı:</strong> Verideki cinsiyet, ırk, yaş gibi dengesizlikler model çıktısında hızla ortaya çıkar.</li><li><strong>Kültürel ve dilsel temsil:</strong> İngilizce ağırlıklı veri, az temsil edilen dillerin ve kültürlerin model tarafından zayıf anlaşılmasına yol açar. Türkçe için de aynı durum geçerli.</li><li><strong>Toksik içerik filtreleme:</strong> Nefret söylemi, şiddet ve ayrımcılığın filtrelenmesi gerekli. Ancak aşırı filtreleme, bazı toplulukların dilini (örneğin lehçe veya kimlik odaklı konuşmaları) yanlışlıkla “toksik” sayıp veriden silebilir. Bu da başka bir tür önyargı üretir.</li><li><strong>Benchmark kirlenmesi:</strong> Değerlendirme verilerinin eğitim setine sızması, model başarısını olduğundan yüksek gösterir. Cross-dataset dedup bu yüzden önemli.</li></ul><h3>Sonuç: Veri İşleme Sıkıcı Değil, Belirleyici</h3><p>Bir LLM’in kalitesini belirleyen şeyler listesinde mimari ve hesaplama gücü başı çekiyor gibi görünse de, sahadaki deneyim sürekli aynı yere işaret ediyor: <strong>verinin kalitesi, çeşitliliği ve temizliği modelin tavanını belirler.</strong></p><p>Özetle akılda tutulması gerekenler:</p><ol><li><strong>Toplama:</strong> Tek kaynağa güvenmeyin. Web, kitap, akademik içerik, forum ve sentetik veriyi dengeli karıştırın.</li><li><strong>Temizleme:</strong> Kural tabanlı ve model tabanlı filtreleri birlikte kullanın, ama aşırı filtrelemeye karşı dikkatli olun.</li><li><strong>Deduplikasyon:</strong> Hem kalite hem ezber hem de benchmark kirlenmesi için kritik.</li><li><strong>Tokenization:</strong> Dilinize uygun bir tokenizer, hem maliyet hem performans demek. Türkçe için özellikle önemli.</li><li><strong>Pipeline:</strong> Karıştırma, paketleme ve karışım oranları eğitimin verimini ve modelin karakterini şekillendirir.</li><li><strong>Augmentasyon:</strong> Sentetik veri güçlü bir araç, ama dikkatli denetlenmezse kendi hatalarını büyütür.</li><li><strong>Etik:</strong> Gizlilik, telif, önyargı ve şeffaflık, pipeline’ın sonradan eklenen bir parçası değil, her adımının ayrılmaz bir bileşeni.</li></ol><p>Bir sonraki sefer bir LLM’in cevabına hayran kaldığınızda, bunun arkasındaki yüzlerce terabaytlık temizleme, eleme ve karıştırma emeğini hatırlayın. Modelin “zekâsı”, büyük ölçüde o görünmez işin sonucudur.</p><p><em>Bu yazı hoşunuza gittiyse, bir alkış bırakıp takip etmeyi unutmayın. Hangi aşamayı daha derin işlememi isterdiniz? Yorumlarda yazın.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6a3c89344683" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Büyük Modelin Aklını Küçüğe Aktarmak: LLM Damıtma (Knowledge Distillation) Nasıl Çalışır?]]></title>
            <link>https://medium.com/@eren.alltun/b%C3%BCy%C3%BCk-modelin-akl%C4%B1n%C4%B1-k%C3%BC%C3%A7%C3%BC%C4%9Fe-aktarmak-llm-dam%C4%B1tma-knowledge-distillation-nas%C4%B1l-%C3%A7al%C4%B1%C5%9F%C4%B1r-9bb87737ebea?source=rss-a95e2cc08f44------2</link>
            <guid isPermaLink="false">https://medium.com/p/9bb87737ebea</guid>
            <dc:creator><![CDATA[Eren ALTUN]]></dc:creator>
            <pubDate>Tue, 10 Nov 2026 16:12:42 GMT</pubDate>
            <atom:updated>2026-11-10T16:12:42.218Z</atom:updated>
            <content:encoded><![CDATA[<p><em>7 milyar parametrelik bir modelin bilgisini 0.5 milyarlık bir modele nasıl öğretiriz? Hem mantığı hem Colab’da çalışan kodu adım adım anlatıyorum.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sW8M6zTw0f2P5SwRxqDAZQ.jpeg" /></figure><h3>Neden damıtma?</h3><p>Büyük dil modelleri güçlü ama pahalı. 7B’lik bir model fp16&#39;da yaklaşık 15 GB bellek ister, telefonda ya da küçük bir sunucuda çalıştırmak pratik değil. 0.5B’lik bir model ise neredeyse her yerde çalışır ama tek başına eğitildiğinde belirgin biçimde daha zayıftır.</p><p>Damıtma şu soruyu sorar: <strong>Küçük modeli sadece “doğru cevabı” göstererek değil, büyük modelin düşünme biçimini göstererek eğitirsek ne olur?</strong></p><h3>Sezgi: Usta ve çırak</h3><p>Bir ustanın çırağına sadece “bu doğru, bu yanlış” dediğini düşün. Çırak sonucu öğrenir ama nedenini öğrenmez. Usta ise şöyle de diyebilir: “Bu cevap doğru, ama şu ikinci seçenek de fena sayılmaz, üçüncüsü ise tamamen saçma.” İşte ikinci tür bilgi çok daha zengindir.</p><p>Damıtmada öğretmen model usta, öğrenci model çıraktır. Öğrenci, öğretmenin <strong>tüm olasılık dağılımını</strong> taklit etmeye çalışır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ws6SoW51MJ8kQ2W6RcbNJA.jpeg" /></figure><h3>“Karanlık bilgi” (dark knowledge)</h3><p>Normal eğitimde hedef tek bir kelimedir (one-hot etiket): “doğru token şu, gerisi yanlış.” Ama öğretmen model aslında şöyle düşünür:</p><pre>Token     Öğretmenin olasılığı<br>kedi       0.875<br>köpek      0.118<br>araba      0.006</pre><p>Burada “köpek”in olasılığı “araba”dan çok daha yüksek. Çünkü model, kedi ile köpeğin birbirine anlamca yakın olduğunu <strong>biliyor</strong>. Bu benzerlik bilgisi tek bir doğru etikette yok, ama öğretmenin dağılımında var. Hinton ve arkadaşları buna <em>dark knowledge</em> (karanlık bilgi) dedi.</p><h3>Sıcaklık (Temperature): Dağılımı yumuşatmak</h3><p>Sorun şu: öğretmen çok emin olduğunda (0.999 gibi) küçük olasılıklar o kadar küçülür ki öğrenci onları göremez. Çözüm, softmax’a bir <strong>sıcaklık (T)</strong> eklemek:</p><pre>p_i = exp(z_i / T) / Σ exp(z_j / T)</pre><p>Yukarıdaki örnekte logit’ler [5, 3, 0] olsun:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/552/1*3-wQ_tuPnJJ7QcddCpudnQ.png" /></figure><p>T büyüdükçe dağılım yumuşar, “köpek” gibi ikinci tercihler görünür hale gelir. Öğrenci için ders içeriği zenginleşir. Bu projede T = 2 kullandım; pratikte 1–4 arası tipiktir.</p><h3>Kayıp fonksiyonu: İki öğretmenden ders almak</h3><p>Öğrencinin iki kaynağı var: öğretmenin dağılımı ve gerçek cevap. Kayıp ikisini birleştirir:</p><pre>L = α · T² · KL(p_öğretmen || p_öğrenci) + (1 − α) · CE(y, p_öğrenci)</pre><ul><li><strong>KL (Kullback-Leibler) ıraksaması:</strong> İki dağılımın birbirinden ne kadar uzak olduğunu ölçer. “Öğretmen gibi düşün” kısmı.</li><li><strong>CE (cross-entropy):</strong> Gerçek etiketi ne kadar iyi tahmin ettiğini ölçer. “Doğruyu da bil” kısmı.</li><li><strong>α:</strong> İkisi arasındaki denge. Ben 0.7 kullandım: %70 öğretmeni taklit, %30 gerçek etiket.</li><li><strong>T²:</strong> Sıcaklık yükseldikçe gradyanlar küçülür. T² ile çarparak KL teriminin ölçeğini CE ile dengeli tutuyoruz.</li></ul><p>Kodda bu şöyle görünüyor:</p><pre>def distill_loss(s_logits, t_logits, labels, T=2.0, alpha=0.7):<br>    s = s_logits[:, :-1, :VOCAB].float()   # öğrenci çıktısı<br>    t = t_logits[:, :-1, :VOCAB].float()   # öğretmen çıktısı<br>    y = labels[:, 1:]                      # bir sola kaydırılmış etiketler<br>    m = (y != -100)                        # sadece cevap token&#39;ları<br><br>    s_m, t_m = s[m], t[m]<br><br>    s_logp = F.log_softmax(s_m / T, dim=-1)<br>    t_logp = F.log_softmax(t_m / T, dim=-1)<br><br>    kl = F.kl_div(s_logp, t_logp, log_target=True,<br>                  reduction=&quot;batchmean&quot;) * (T * T)<br>    ce = F.cross_entropy(s_m, y[m])<br><br>    return alpha * kl + (1 - alpha) * ce</pre><p>Dikkat edilecek iki nokta: Etiketleri bir sola kaydırıyoruz, çünkü dil modelleri <em>bir sonraki</em> token’ı tahmin eder. KL için hem öğrenci hem öğretmen <strong>aynı T</strong> ile yumuşatılır, CE ise normal (T’siz) logit’lerle hesaplanır.</p><h3>Projenin mimarisi</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MOb6_gjSGHo2r827xAKKyA.jpeg" /></figure><p>Öğretmen <strong>sadece ileri geçiş</strong> yapar, ağırlıkları dondurulur:</p><pre>teacher.eval()<br>for p in teacher.parameters():<br>    p.requires_grad_(False)</pre><p>Eğitim döngüsünde de öğretmen torch.no_grad() içinde çalışır; bu hem bellek hem hız kazandırır. Güncellenen tek model öğrencidir.</p><blockquote><strong><em>Küçük GPU’da ipucu:</em></strong><em> T4/L4 gibi kartlarda öğretmeni 4-bit (NF4) nicemlemeyle yüklüyorum. 7B model ~15 GB yerine ~5 GB tutuyor. Öğretmen zaten sadece “soru cevaplayan” konumunda olduğu için hafif kalite kaybı öğrenciyi çok etkilemiyor.</em></blockquote><h3>Veri hazırlama: Prompt maskeleme</h3><p>Veri seti olarak yahma/alpaca-cleaned (talimat + cevap) kullandım. Her örnek modelin sohbet şablonuna yerleştiriliyor:</p><pre>&lt;|im_start|&gt;user<br>Fransa&#39;nın başkenti neresidir?&lt;|im_end|&gt;<br>&lt;|im_start|&gt;assistant<br>Paris&#39;tir.&lt;|im_end|&gt;</pre><p>Burada kritik bir detay var: <strong>kaybı sadece cevap token’larında hesaplıyoruz.</strong> Soru kısmında öğrencinin öğretmeni taklit etmesinin bir anlamı yok, çünkü soruyu zaten biz veriyoruz. Bunu -100 etiketiyle yapıyoruz (PyTorch bu değeri kayıpta yok sayar):</p><pre>labels = [-100] * n_prompt + ids[n_prompt:]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U4QJC2tLkluIJ6Z9X4B1pg.jpeg" /></figure><h3>Küçük ama can sıkıcı bir sorun: Vocab uyuşmazlığı</h3><p>Qwen 7B’nin çıkış katmanı 152.064, 0.5B’ninki 151.936 boyutunda. KL hesaplamak için iki dağılımın aynı boyutta olması gerekir. Fazladan olan kısım gerçek token değil, sadece dolgu. Bu yüzden ortak olan kısmı alıyoruz:</p><pre>VOCAB = min(teacher.config.vocab_size, student.config.vocab_size, len(tokenizer))</pre><p>Buradan çıkan genel ders: <strong>Logit tabanlı damıtmada öğretmen ve öğrenci aynı tokenizer’ı paylaşmalı.</strong> Aynı model ailesinden seçmek (Qwen→Qwen, Llama→Llama) en sorunsuz yoldur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/1*v6KCCyOuqXS9-4VZ4pVIUA.png" /></figure><h3>Sonuçlar</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P4Mehx5WPI-9_vs_RKynUg.png" /></figure><p><strong>Grafikleri nasıl okumalı?</strong></p><p>Soldaki grafikte üç eğri var. <strong>KL</strong>, öğrencinin öğretmenin olasılık dağılımına ne kadar yakın olduğunu gösterir; düşmesi taklidin işlediği anlamına gelir. <strong>CE</strong> (cross-entropy), öğrencinin veri setindeki gerçek cevabı ne kadar iyi tahmin ettiğini ölçer. <strong>Toplam</strong> ise ikisinin ağırlıklı karışımıdır (0.7 × KL + 0.3 × CE) ve eğitimin gerçekten düşürmeye çalıştığı değerdir.</p><p>Sağdaki grafik <strong>perplexity</strong>’yi gösterir; bu, CE’nin üstelidir (e^CE) ve modelin her kelimede ortalama kaç seçenek arasında kararsız kaldığını anlatır. Düşük olması iyidir.</p><p>İlginç olan şu: KL belirgin biçimde düşerken perplexity başlangıca göre hafifçe yükseldi. Bunun makul bir açıklaması, eğitimin büyük kısmının öğretmeni taklit etmeye ayrılmış olması; öğrenci veri setinin ham cevaplarından çok öğretmenin tarzına yaklaşıyor. Bu yüzden damıtmanın başarısını tek bir metrikle değil, üretilen cevapların kalitesiyle birlikte değerlendirmek gerekir.</p><h3>Sınırlamalar</h3><ul><li>0.5B model, 7B’nin yerini <strong>tutmaz</strong>. Damıtma farkı kapatır ama sıfırlamaz; özellikle muhakeme ve uzun bağlam zayıf kalır.</li><li>Veri setinin kalitesi sonucu doğrudan etkiler. Alpaca nispeten basit bir veri seti.</li><li>Bu yöntemde öğretmenin her adımda çalıştırılması gerekiyor; eğitim süresinin büyük kısmı öğretmenin ileri geçişine gidiyor. Alternatif olarak öğretmen çıktıları önceden hesaplanıp saklanabilir (ama vocab boyutu yüzünden disk maliyeti büyük).</li><li>Logit’lere erişim gerekir. GPT-4 gibi kapalı modellerden logit alamazsınız; orada öğretmenin ürettiği <strong>metinle</strong> eğitmek (sequence-level distillation) tek yoldur.</li></ul><h3>Denemek isteyenler için</h3><ul><li>max_train_samples’ı 50–100k’ya çıkarıp 2 epoch deneyin.</li><li>Türkçe bir talimat veri setiyle değiştirip Türkçe performansı ölçün.</li><li>alpha ve T değerlerini oynatıp etkilerini karşılaştırın (α → 1 olunca öğrenci öğretmene daha çok bağlanır).</li></ul><h3>Kapanış</h3><p>Damıtma, “daha büyük model = daha iyi” denkleminin pratikteki çözümlerinden biri. Büyük modelin ürettiği olasılık dağılımı, tek bir doğru cevaptan çok daha fazla bilgi taşıyor ve bu bilgiyi küçük bir modele aktarmak, onu sıfırdan eğitmekten çok daha verimli.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9bb87737ebea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LangChain’i Baştan Sona Anlamak: Prototipten Üretime Eksiksiz Rehber]]></title>
            <link>https://medium.com/@eren.alltun/langchaini-ba%C5%9Ftan-sona-anlamak-prototipten-%C3%BCretime-eksiksiz-rehber-a1d3d9d6870b?source=rss-a95e2cc08f44------2</link>
            <guid isPermaLink="false">https://medium.com/p/a1d3d9d6870b</guid>
            <dc:creator><![CDATA[Eren ALTUN]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 16:42:09 GMT</pubDate>
            <atom:updated>2026-11-09T16:42:09.592Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Modeller, araçlar, ajanlar, bellek ve RAG’dan LangGraph’a, değerlendirmeden güvenliğe: LangChain 1.x ile gerçek dünyaya hazır bir LLM uygulaması yazmanın yol haritası.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ERXC8yeH-YbD7SP1VsvkiQ.jpeg" /></figure><p>Bir LLM demosu yazmak bir akşamlık iştir. Asıl zorluk ertesi gün başlar: Ajan neden yanlış aracı seçti? Fatura neden beklediğin kadarın üç katı geldi? Kötü niyetli bir web sayfası asistanı kandırırsa ne olacak?</p><p>Bu yazıda kod yığınına boğulmadan, önce LangChain’in <strong>mantığını</strong>, sonra bir uygulamayı prototipten üretime taşıyan beş konuyu anlatıyorum. Tam kod örnekleri için <a href="https://docs.langchain.com/">docs.langchain.com</a> var; burada amaç, parçaların neden var olduğunu ve ne zaman hangisini seçeceğini görmek. Anlatım LangChain 1.x ve LangGraph 1.x’e göre.</p><h3>Bölüm 1: LangChain’in mantığı</h3><h3>LangChain ne işe yarar?</h3><p>LangChain, farklı model sağlayıcılarını (OpenAI, Anthropic, Google, yerel modeller) <strong>tek bir ortak arayüzün</strong> arkasına koyar. Üstüne de araç kullanımı, bellek, kendi verine bağlanma (RAG) ve insan onayı gibi hazır parçalar ekler. Modeli değiştirmek çoğu zaman tek satırlık iştir.</p><p>1.0 sürümüyle çatı sadeleşti: merkezde artık create_agent var ve arka planda LangGraph çalışıyor. Eski “chain” sınıfları langchain-classic paketine taşındı. Bu yüzden internette gördüğün AgentExecutor, LLMChain ya da ConversationBufferMemory içeren eğitimler eski sürümlere ait.</p><h3>Beş temel kavram</h3><p><strong>1. Model.</strong> Bir sohbet modeli, düz metin yerine <strong>mesaj listesi</strong> alır. Her mesajın bir rolü vardır: sistem talimatı, kullanıcı mesajı, modelin cevabı ve araç sonucu. Hepsi aynı metotlarla çalışır: tek çağrı (invoke), parça parça akış (stream) ve toplu çağrı (batch).</p><p><strong>2. Araç (tool).</strong> Modelin çağırabildiği bir Python fonksiyonu. LangChain fonksiyonun adını, açıklamasını (docstring) ve tip ipuçlarını okuyup modele bir şema olarak sunar. Model aracı ne zaman kullanacağına <strong>bu açıklamaya bakarak</strong> karar verir, o yüzden iyi bir docstring yazmak kod kadar önemlidir. Küçük ama kritik bir ayrıntı: model aracı kendisi çalıştırmaz, sadece “şu aracı şu argümanla çağır” isteği üretir. Çalıştırmak ajanın işidir.</p><p><strong>3. Ajan.</strong> Modeli araçlarla birleştirip bir döngüde çalıştırır:</p><ol><li>Kullanıcı mesajı modele gider.</li><li>Model ya bir araç çağırmak ister ya da cevabı verir.</li><li>Araç istediyse çalıştırılır, sonucu mesaj geçmişine eklenir ve model tekrar çağrılır.</li><li>Model araç istemeyi bıraktığında döngü biter.</li></ol><p>Kodu bu kadar kısa:</p><pre>from langchain.agents import create_agent<br>from langchain.tools import tool<br><br>@tool<br>def hava_durumu(sehir: str) -&gt; str:<br>    &quot;&quot;&quot;Verilen şehrin güncel hava durumunu döndürür.&quot;&quot;&quot;<br>    return f&#39;{sehir}: 18°C, parçalı bulutlu&#39;<br><br>ajan = create_agent(model=&#39;openai:gpt-4.1&#39;, tools=[hava_durumu],<br>                    system_prompt=&#39;Türkçe konuşan yardımsever bir asistansın.&#39;)<br><br>sonuc = ajan.invoke({&#39;messages&#39;: [{&#39;role&#39;: &#39;user&#39;, &#39;content&#39;: &#39;İzmir’de hava nasıl?&#39;}]})</pre><p>Hata ayıklarken sonuc[&#39;messages&#39;] listesini baştan sona yazdır: kullanıcı mesajı, araç çağrıları, araç sonuçları ve son cevap burada, yani ajanın nasıl “düşündüğünü” görürsün.</p><p><strong>4. Bellek.</strong> Ajan varsayılan olarak her çağrıyı bağımsız işler. Konuşmayı hatırlaması için iki şey verirsin: durumu her adımda kaydeden bir <strong>checkpointer</strong> ve her konuşmayı ayıran bir <strong>thread_id</strong>. Bu <em>kısa süreli</em> bellektir. Konuşmalar arasında kalıcı bilgi (kullanıcı tercihleri gibi) için <em>uzun süreli</em> bellek, yani LangGraph’ın store yapısı kullanılır. Üretimde bellek içi (InMemorySaver) yerine Postgres ya da SQLite tabanlı bir checkpointer kullan; yoksa süreç kapanınca her şey unutulur.</p><p><strong>5. Middleware.</strong> Ajan döngüsünün belirli noktalarına kanca takmanı sağlar: modelden önce (before_model), modelden sonra (after_model), model çağrısını sararak (wrap_model_call) ve araç çağrısını sararak (wrap_tool_call). Hazır olanlar günlük işlerin çoğunu çözer: uzun geçmişi özetlemek, kişisel veriyi maskelemek, belirli araçlardan önce insan onayı istemek, çağrı sayısını sınırlamak.</p><p>İki küçük parça daha: <strong>yapılandırılmış çıktı</strong> (modelden serbest metin yerine Pydantic şemasına uyan bir nesne almak, böylece başka sisteme aktarırken ayrıştırma hatası olmaz) ve <strong>streaming</strong> (cevabı parça parça göstermek, algılanan hızı ciddi artırır).</p><h3>LCEL: sabit adımlı zincirler</h3><p>LangChain’deki hemen her bileşen (prompt, model, parser, retriever) bir <strong>Runnable</strong>’dır ve aynı arayüzü paylaşır. <strong>LCEL</strong> bu bileşenleri | operatörüyle art arda bağlar: bir adımın çıktısı sonrakinin girdisi olur. Tipik zincir şöyle görünür: prompt | model | parser.</p><p>Burada kafa karıştıran nokta şu: LCEL için model <strong>şart değil</strong>. Kendi Python fonksiyonlarını RunnableLambda ile sarıp sırayla çalıştırabilirsin:</p><pre>from langchain_core.runnables import RunnableLambda<br><br>def temizle(metin): return metin.strip().lower()<br>def kelime_say(metin): return {&#39;metin&#39;: metin, &#39;kelime_sayisi&#39;: len(metin.split())}<br><br>zincir = RunnableLambda(temizle) | RunnableLambda(kelime_say)<br>zincir.invoke(&#39;  Merhaba Dünya Nasılsın  &#39;)   # {&#39;metin&#39;: &#39;merhaba dünya nasılsın&#39;, &#39;kelime_sayisi&#39;: 3}</pre><p>Sadece iki fonksiyonu art arda çalıştıracaksan düz kelime_say(temizle(x)) yeterli. LCEL’in asıl kazancı zincire akış (stream), toplu çağrı (batch), asenkron çalışma, izleme ve paralel adımlar (RunnableParallel) bedavaya gelmesi.</p><p><strong>Hangisini seçmeli?</strong> Adımlar önceden belliyse (özetle, çevir, sınıflandır) LCEL zinciri yeterli ve daha öngörülebilirdir. Hangi adımı atacağına modelin kendisinin karar vermesi gerekiyorsa ajan kullan.</p><h3>RAG: kendi verinle soru-cevap</h3><p>Model, eğitim verisinde olmayan şirket belgeleri ya da güncel bilgiler hakkında doğru cevap veremez. <strong>RAG</strong> bunu şöyle çözer: cevap vermeden önce ilgili belge parçalarını bulur ve modele bağlam olarak verir. İki aşaması var:</p><ul><li><strong>Hazırlık (belgeler değiştikçe tekrarlanır):</strong> Belgeyi yükle, küçük parçalara böl, her parçayı sayısal vektöre çevir (<em>embedding</em>), vektör veritabanına yaz.</li><li><strong>Her soruda:</strong> Soruyu da vektöre çevir, en benzer parçaları bul, bunları bağlam olarak modele ver.</li></ul><p>Bunu iki şekilde kurabilirsin. <strong>Ajanlı RAG</strong>’da arama bir araçtır; ajan gerekirse birden fazla arama yapar ya da hiç yapmaz. <strong>Zincir RAG</strong>’da her soruda tek arama yapılır; daha hızlı ve öngörülebilirdir, basit SSS botları için genelde yeterlidir.</p><h3>MCP: araçları standart hale getirmek</h3><p>Model Context Protocol (MCP), araçları standart bir protokolle sunan sunuculardır. langchain-mcp-adapters paketi bu sunuculardaki araçları LangChain aracına çevirir. Yani bir kez yazdığın MCP sunucusunu her ajanda yeniden kullanabilirsin.</p><h3>Bölüm 2: Prototipten üretime</h3><p>Ajanın çalışıyor. Şimdi şu sorular geliyor: Doğru mu? Ucuz mu? Güvenli mi? Beş konu bu soruları yanıtlıyor ve her biri bir öncekinin üzerine biniyor.</p><h3>1. LangGraph: akışı kendin çiz</h3><p>create_agent çoğu iş için yeterli. Akışın tamamen senin kontrolünde olması gerektiğinde (dallanan iş akışları, çok ajanlı sistemler, saatler süren işler) LangGraph’a geçersin. Fikir şu: ajanın akışını bir <strong>graf</strong> olarak tanımlarsın.</p><ul><li><strong>Durum (state):</strong> Grafın ortak hafızası. Her düğüm durumu okur, sadece değiştirmek istediği alanları döndürür. Bir alanın <em>nasıl</em> güncelleneceğini <strong>reducer</strong> belirler (üzerine yazmak mı, listeye eklemek mi). Durumu küçük tut: büyük belge yerine kimliğini sakla.</li><li><strong>Düğüm (node):</strong> İş yapan fonksiyon (modeli çağırır, araç çalıştırır, kontrol eder).</li><li><strong>Kenar (edge):</strong> Sıradaki adımı belirler. Sabit olabilir ya da bir fonksiyonun sonucuna göre dallanabilir. Bir kenarı önceki düğüme döndürürsen <strong>döngü</strong> elde edersin (örneğin “yaz, denetle, yetersizse yeniden yaz”). Döngüye mutlaka çıkış koşulu koy; LangGraph ayrıca toplam adım sayısını recursion_limit ile sınırlar.</li></ul><p>Grafın üç önemli yeteneği var:</p><ul><li><strong>Kalıcılık:</strong> Checkpointer her adımdan sonra durumun anlık görüntüsünü kaydeder. Bu sayede konuşma belleği, hata sonrası kaldığı yerden devam ve geçmiş bir adıma dönüp farklı bir yol denemek (“zaman yolculuğu”) mümkün olur.</li><li><strong>İnsan onayı (</strong><strong>interrupt):</strong> Graf bir noktada durur, durumu kaydeder ve cevap bekler. Kullanıcı saatler sonra onaylasa bile aynı yerden devam eder. Dikkat: devam ederken interrupt içeren düğüm <strong>baştan</strong> çalışır, o yüzden interrupt’tan önce e-posta gönderme gibi yan etkisi olan kod koyma.</li><li><strong>Çok ajanlı yapılar:</strong> Tek ajana çok araç vermek doğruluğu düşürür. En sade çözüm alt ajanları <strong>araç olarak sarmalamak</strong>: yönetici ajan onları sıradan araçlar gibi çağırır ve her alt ajan kendi bağlamında çalışır. Yönetici sadece sonuçları görür, bağlamı şişmez.</li></ul><h3>2. İleri RAG: doğru belgeyi bulmak</h3><p>Doğru cevabın ön koşulu doğru belgeyi bulmaktır. “1000 karakterlik parçalara böl, en benzer 4’ünü getir” yaklaşımı demo için yeter, gerçek veride tıkanır. Her belirtinin bilinen bir çözümü var:</p><ul><li><strong>Ürün kodu ya da isim gibi tam eşleşmeler bulunmuyor.</strong> Vektör araması anlama bakar, kelimeye değil. Çözüm: <strong>hibrit arama</strong> (anlam araması + anahtar kelime araması, sonuçlar birleştirilir).</li><li><strong>Doğru parça geliyor ama 7. sırada.</strong> Çözüm: <strong>yeniden sıralama (reranking)</strong>. Önce hızlıca 20–50 aday getirilir, sonra daha isabetli ama yavaş bir model adayları soruyla birlikte okuyup puanlar.</li><li><strong>Cevap yarım, bilgi iki parçaya bölünmüş.</strong> Çözüm: <strong>daha iyi parçalama</strong>.</li><li><strong>Kısa ya da belirsiz soruda yanlış belge geliyor.</strong> Çözüm: <strong>sorgu dönüşümü</strong> (soruyu geçmişten bağımsız hale getirmek, birkaç farklı biçimde yeniden yazmak).</li><li><strong>Eski sürüm ya da yanlış departmanın belgesi geliyor.</strong> Çözüm: <strong>metadata filtreleme</strong> (departman, tarih, sürüm gibi alanlarla).</li></ul><p>Parçalamanın kuralı basit: <strong>bir parça tek başına okunduğunda anlamlı olmalı.</strong> Bunun için başlıklara göre böl ve her parçanın başına belge ve bölüm adını yaz: “İzin süresi 14 gündür” tek başına belirsizdir, ama “[İK Yönetmeliği &gt; Yıllık İzin]” önekiyle doğru sorguda bulunur.</p><p>İki güvenlik notu: Erişim yetkisi filtresini asla modele bırakma, kullanıcının oturumundan kodla ekle. Her tekniğin gecikme ve maliyeti vardır, o yüzden önce ölç, sonra ekle.</p><h3>3. Değerlendirme: kaliteyi sayıyla gör</h3><p>“Bence daha iyi oldu” ile “doğruluk %71’den %84’e çıktı” arasındaki fark değerlendirmedir. Değerlendirme olmadan her prompt ya da model değişikliği bir kumardır.</p><ul><li><strong>Test seti:</strong> 20–50 iyi seçilmiş örnekle başla. Gerçek sorular, zor örnekler (belirsiz sorular, cevabı belgede olmayanlar, yani “bilmiyorum” demesi gerekenler) ve üretimde yanlış cevaplanmış her soru sete girer. Beklenen çıktı kelimesi kelimesine cevap değil, cevabın içermesi gereken anahtar bilgidir.</li><li><strong>Değerlendirici türleri:</strong> Kural tabanlı kod (hızlı, kesin ama anlamı ölçemez), referansla karşılaştırma, <strong>LLM-as-judge</strong> (bir model cevabı puanlar; esnek ama kendisi de hata yapar) ve insan değerlendirmesi (en güvenilir, en yavaş). Pratikte hepsi birlikte kullanılır.</li><li><strong>Güvenilir hakem için üç kural:</strong> Tek bir ölçüt sor, gerekçeyi puandan önce yazdır, dar bir ölçek kullan (geçti/kaldı gibi). Hakemi de test et: 20–30 örneği elle puanla, uyum %85’in altındaysa önce hakemi düzelt.</li><li><strong>RAG’da iki ayrı ölçüm:</strong> Arama doğru belgeleri getirdi mi (bağlam isabeti ve kesinliği) ve model o belgelere sadık kaldı mı (sadakat, yani uydurma var mı). Hatanın hangi aşamada olduğunu bilmek neyi düzelteceğini söyler.</li><li><strong>Ajanda üç seviye:</strong> Son cevap doğru mu, gidiş yolu makul mü (doğru araçlar, gereksiz tekrar yok), tek adımda doğru aracı seçti mi.</li></ul><p>Bunu alışkanlık yap: prompt, model ya da arama ayarı her değiştiğinde deneyi çalıştır, küçük bir alt seti CI hattına ekle, üretimde olumsuz geri bildirim alan konuşmaları haftalık sete ekle.</p><h3>4. Gözlemlenebilirlik ve maliyet</h3><p>Ajan bir kara kutu gibi davranır: aynı soruya bazen 2, bazen 9 adımda cevap verir. Ne olduğunu görmeden ne hatayı ne de maliyeti kontrol edebilirsin.</p><ul><li><strong>Tracing:</strong> Bir izleme (trace) tek bir isteğin tüm adımlarını gösterir: her model çağrısı, araç çağrısı, süre ve token sayısı. LangSmith’te iki ortam değişkeniyle açılır. İzlemeyi projenin <strong>ilk gününden</strong> aç. İzlerde şunlara bak: gecikme hangi adımda, ajan aynı aracı tekrar tekrar çağırıyor mu, bağlam her adımda şişiyor mu.</li><li><strong>Maliyetin asıl kaynağı:</strong> Çoğu zaman çıktı değil, her adımda yeniden gönderilen <strong>girdi</strong>dir. 8 adımlı bir ajan sistem prompt’unu ve tüm geçmişi 8 kez gönderir. Uzun araç çıktılarını kısaltmak ve geçmişi özetlemek en etkili tasarruftur.</li><li><strong>Önbellek:</strong> Tam eşleşme önbelleği (aynı girdiye kayıtlı cevap), anlamsal önbellek (benzer soruya kayıtlı cevap, yanlış eşleşme riskli) ve sağlayıcı prompt önbelleği (sabit prompt başlangıcı ucuzlar). Sonuncudan yararlanmak için prompt’u <strong>sabit kısım önce, değişken kısım sonra</strong> düzenle.</li><li><strong>Model yönlendirme:</strong> Sınıflandırma, özetleme gibi basit adımları küçük modele ver, zor adımları büyüğe. Kaliteyi test setiyle doğrula.</li><li><strong>Limitler:</strong> Kontrolden çıkan bir döngü tek istekte ciddi maliyet yaratabilir. Model ve araç çağrı sayısına limit koy, ana model hata verirse yedek model tanımla, timeout ve yeniden deneme ayarla.</li></ul><h3>5. Güvenlik</h3><p>Ajan dış dünyadan veri okuyup araç çalıştırdığında, okuduğu <strong>her metin</strong> onu yönlendirmeye çalışabilir. Saldırı yüzeyi sadece kullanıcı mesajı değil, ajanın okuduğu web sayfaları, e-postalar ve RAG belgeleridir.</p><p>En kritik tasarım kuralı: şu üç özellik aynı ajanda birleşirse risk en yüksek seviyeye çıkar: <strong>özel verilere erişim</strong>, <strong>güvenilmeyen içerik okuma</strong> ve <strong>dışarıya veri gönderebilme</strong>. Bu üçünden en az birini kırmak en sağlam savunmadır.</p><ul><li><strong>Prompt injection:</strong> Doğrudan (kullanıcı “talimatları unut” der) ya da dolaylı olabilir (ajanın okuduğu sayfaya gizlenmiş talimat). Sadece prompt yazarak tamamen önlemenin bilinen bir yolu yok, çünkü model talimat ile veriyi güvenilir biçimde ayıramaz. Bu yüzden savunma, modelin kandırılabileceğini varsayıp <strong>yapabileceklerini sınırlamaya</strong> dayanır.</li><li><strong>En az yetki:</strong> Kısıtlamaları modelin isteğine değil kodun içine yaz: izinli alan adları ve tablolar, parametreli sorgular, salt okunur veritabanı kullanıcısı, ağsız sandbox. Modele ham SQL, shell komutu ya da serbest URL çağrısı yaptıran araç verme.</li><li><strong>Kimlik oturumdan gelsin:</strong> Kullanıcıya özel veri getiren araçta kullanıcı kimliğini modelden değil, oturumdan al; model başkasının kimliğini uyduramasın.</li><li><strong>İnsan onayı:</strong> Gönderme, silme, ödeme gibi geri alınamaz eylemlerde onay iste.</li><li><strong>Kişisel veri:</strong> KVKK ve GDPR açısından kişisel veriyi modele, loglara ve izleme sistemine gitmeden maskele.</li><li><strong>Çıktıyı güvenilmeyen girdi gibi ele al:</strong> HTML’e basıyorsan kaçış karakterleriyle işle, harici resim bağlantılarını engelle (veri sızdırmak için kullanılabilir), kod ya da SQL olarak asla doğrudan çalıştırma, yapılandırılmış veriyi şemayla doğrula.</li></ul><p>Yayına almadan önce kendine sor: Her aracın yetkisi kodda sınırlı mı? Geri alınamaz eylemlerde onay var mı? Güvenilmeyen içerik okuyan ajan dışarıya veri gönderebiliyor mu? Kişisel veri maskeleniyor mu? Limitler tanımlı mı? Bilinen enjeksiyon denemeleri test setinde var mı?</p><h3>Kapanış</h3><p>Önerdiğim sıra: önce temelleri çalıştır (model, araç, create_agent, bellek). Sonra kendi belgelerinle bir RAG kur ve <strong>hemen</strong> 30 soruluk bir test seti hazırla. Ardından parçalama, hibrit arama ve reranking ekle, her adımın etkisini ölç. Sonra izlemeyi ve maliyet limitlerini aç. En sonda kendi ajanına saldır ve savunmaları ekle. Akış karmaşıklaşırsa LangGraph’a geç.</p><p>İşin özü tek cümle: <strong>önce ölç, sonra geliştir.</strong> Bir demoyu etkileyici yapan şey modeldir. Bir ürünü güvenilir yapan şey ise ölçüm, gözlem ve sınırlardır.</p><p><em>Sürüm bilgileri Kasım 2026 itibarıyla. Model adları ve middleware parametreleri sürümler arasında değişebilir; güncel ayrıntılar için </em><a href="https://docs.langchain.com/"><em>docs.langchain.com</em></a><em> ve </em><a href="https://genai.owasp.org/"><em>OWASP GenAI</em></a><em> kaynaklarına bakabilirsin.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a1d3d9d6870b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LLM Değerlendirme, Yapay Zekâ Modelinizin İyi Olduğunu Nereden Biliyorsunuz?]]></title>
            <link>https://medium.com/@eren.alltun/llm-de%C4%9Ferlendirme-yapay-zek%C3%A2-modelinizin-i%CC%87yi-oldu%C4%9Funu-nereden-biliyorsunuz-65bc695c920a?source=rss-a95e2cc08f44------2</link>
            <guid isPermaLink="false">https://medium.com/p/65bc695c920a</guid>
            <dc:creator><![CDATA[Eren ALTUN]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 16:41:58 GMT</pubDate>
            <atom:updated>2026-11-09T16:41:58.130Z</atom:updated>
            <content:encoded><![CDATA[<p><em>LLM değerlendirmesinin can alıcı noktaları: metriklerden ajan testlerine, yargıç modellerden istatistik tuzaklarına.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qjliF1YqZeZcwR13tw6z-Q.jpeg" /></figure><p>“Model A %78, Model B %76. Demek ki A daha iyi.”</p><p>Çoğumuz bu cümleyi bir kez de olsa kurduk. Ve çoğu zaman yanılıyorduk.</p><p>Klasik makine öğrenmesinde işler basitti: bir test seti, bir doğruluk skoru, bitti. LLM’lerde ise çıktılar serbest metin. Aynı soruya onlarca farklı doğru cevap verilebiliyor, model davranışı prompt’a göre değişiyor, “iyi cevap” da göreve göre farklı anlama geliyor. Bu yüzden LLM değerlendirmesi tek bir sayı değil, birbirini tamamlayan ölçümlerden oluşan bir <strong>sistem</strong>.</p><p>Bu yazıda o sistemin parçalarını, her birinin tuzağıyla birlikte anlatacağım.</p><h3>Neden ölçüyoruz?</h3><p>Ölçemediğiniz modeli geliştiremez, güvenle yayına alamaz, başka bir modelle de karşılaştıramazsınız. Pratikte dört işe yarar:</p><ul><li><strong>Model seçimi:</strong> Hangi modelin sizin göreviniz için kalite, maliyet ve gecikme dengesini en iyi sunduğunu bulmak.</li><li><strong>Regresyon önleme:</strong> Prompt, model sürümü veya RAG ayarı değiştiğinde kalitenin düşmediğini doğrulamak.</li><li><strong>Güvenlik ve uyum:</strong> Zararlı içerik, önyargı, halüsinasyon ve jailbreak’e karşı dayanıklılığı yayından önce görmek.</li><li><strong>Araştırma ilerlemesi:</strong> Yeni bir eğitim tekniğinin gerçekten yetenek kazandırıp kazandırmadığını tarafsızca göstermek.</li></ul><p>Değerlendirmeleri üç eksende sınıflandırmak işe yarıyor. <br>Birincisi <strong>yetenek ve davranış</strong>: model ne yapabilir (bilgi, matematik, kodlama) ve nasıl davranır (talimata uyum, ton, dürüstlük)?</p><p>İkincisi <strong>çevrimdışı ve çevrimiçi</strong>: sabit veri setinde yayından önce yapılan testler tekrarlanabilir ve ucuzdur, gerçek trafikte yapılan A/B testleri ve beğeni oranları ise gerçeği gösterir. İkisi birlikte kullanılmalı, çünkü çevrimdışı skorlar gerçek kullanımı her zaman yansıtmaz.</p><p>Üçüncüsü <strong>referanslı ve referanssız</strong>: elinizde “altın” bir cevap varsa çıktıyı onunla karşılaştırırsınız, yoksa rubrik, ikili karşılaştırma veya bağlama sadakat kontrolü kullanırsınız.</p><h3>Otomatik metrikler: ucuz ama herkesin kör noktası var</h3><p>BLEU, ROUGE, exact match, token F1… Hızlı ve tekrarlanabilirler ama her birinin bir zayıf yanı var:</p><ul><li><strong>Exact match</strong>, “İstanbul” ile “istanbul.” arasındaki farkı hata sayar. Modelin ürettiği metin ile beklenen cevabın karakteri karakterine aynı olması gerekir.</li><li><strong>BLEU</strong> istatistik konusu hem biyoloji, hem finans, hemde fizikte vs kullanılıyor. İstatistik kelimesini her konu için ayrı ayrı hesaplayabiliyorsa başarılı oluyor.</li><li><strong>ROUGE-L</strong> Yapay Zekanın yazdığı sorularda doğru cevabın daha uzun alması konusu.</li><li><strong>BERTScore</strong> anlamsal benzerliği ölçer ama olgusal hatayı yakalamaz. “Paris” ile “Lyon” yakın görünebilir.</li><li><strong>Perplexity</strong> Model konuyla ilgili cevap veriyor mu bakar.</li><li>Token F1 modelin ürettiği metin ile referans (doğru kabul edilen)metin arasındaki kelime/token düzeyindeki örtüşmeyi ölçmek için kullanılan temel metriktir.</li></ul><p>Kod üretiminde standart ölçü <strong>pass@k</strong>’dır: k denemeden en az birinin testleri geçme olasılığı. Doğrudan k örnek üretip “biri geçti mi” diye bakmak yüksek varyanslıdır. Bu yüzden n &gt; k örnek üretilir, c tanesinin geçtiği görülür ve yansız tahmin edici kullanılır:</p><p>pass@k = 1 − C(n−c, k) / C(n, k) (problemler üzerinden ortalaması alınır)</p><p><strong>Türkçe için not:</strong> Eklemeli yapı yüzünden kelime düzeyli metrikler (BLEU, token F1) aynı anlama gelen farklı ek dizilerini hata sayar. Karakter düzeyli <strong>chrF</strong> veya anlamsal yöntemler çoğu zaman çok daha adil sonuç verir.</p><p>Bir de <strong>kalibrasyon</strong> var: model “%90 eminim” dediğinde gerçekten %90 doğru mu? Güven skoru kullanan sistemlerde bu kritik, ama kapalı modellerde olasılıklara erişim olmayabilir.</p><h3>Benchmark’lar: ortak ölçek, ama çabuk eskiyen</h3><p>Benchmark’lar modelleri aynı cetvelle ölçmenizi sağlar. Ama hızla “doyuyor”: en iyi modeller tavana yaklaşınca ayırt edici olmaktan çıkıyorlar.</p><ul><li><strong>Doymuş:</strong> MMLU, GSM8K, HumanEval/MBPP, HellaSwag/ARC</li><li><strong>Hâlâ ayırt edici:</strong> MMLU-Pro, GPQA Diamond (uzman düzeyi fen), Humanity’s Last Exam, MATH/AIME, SWE-bench Verified (gerçek GitHub issue’ları), LiveCodeBench (yeni yayınlanan sorular), ARC-AGI, IFEval (doğrulanabilir talimatlar)</li><li><strong>Tercih tabanlı:</strong> MT-Bench, Arena-Hard ve LMArena (insan oylarıyla Elo/Bradley–Terry)</li></ul><p>Toplu çerçeveler de var: HELM modelleri doğruluk, kalibrasyon, sağlamlık, adalet ve verimlilik gibi birçok boyutta birlikte raporlar. Türkçe için TurkishMMLU ve çok dilli setlerin Türkçe bölümleri kullanılabilir. Güncel skorlar hızla değiştiği için sayı vermiyorum, resmî liderlik tablolarına bakın.</p><h3>LLM-as-a-Judge: yargıç da bir model</h3><p>Güçlü bir modeli başka bir modelin çıktısını puanlamak için kullanmak, insan değerlendirmesinin pahalı ve yavaş olduğu yerde çok cazip. Üç temel kurgusu var:</p><ol><li><strong>Tekil puanlama:</strong> Tek cevap, rubriğe göre puanlanır. Basit ama mutlak ölçekler kayabilir.</li><li><strong>İkili karşılaştırma:</strong> “A mı B mi daha iyi?” İnsan tercihine daha yakın ve daha tutarlıdır.</li><li><strong>Referans destekli:</strong> Yargıca altın cevap da verilir. Olgusal doğruluk ve matematikte güvenilirliği artırır.</li></ol><p>Ama yargıç tarafsız değil. Bilinen önyargıları ve çözümleri şöyle:</p><ul><li><strong>Konum önyargısı:</strong> İlk (veya ikinci) cevabı kayırır. Sırayı değiştirip iki kez sorun, tutarsızsa beraberlik sayın.</li><li><strong>Uzunluk önyargısı:</strong> Uzun cevabı daha iyi bulur. Rubrikte “gereksiz uzunluk ceza alır” deyin, uzunluk kontrollü kazanma oranı raporlayın.</li><li><strong>Kendini kayırma:</strong> Kendi ailesinin çıktısını tercih eder. Farklı aileden yargıç kullanın veya birkaç yargıcın ortalamasını alın.</li><li><strong>Üslup önyargısı:</strong> Markdown’a, emin tona, kibar ifadeye yüksek puan verir. İçerik ve biçimi ayrı kriterlerde puanlatın.</li><li><strong>Sınırlı yetenek:</strong> Çözemediği bir matematik sorusunu doğru puanlayamaz. Referans cevap verin veya programatik kontrol kullanın.</li></ul><p>İyi bir yargıç prompt’u kabaca şöyle görünür: tarafsız bir değerlendirici rolü, soru + (varsa) referans + cevap, net bir rubrik (örneğin doğruluk 0–2, eksiksizlik 0–2, açıklık 0–1), önce her kriter için kısa gerekçe, sonra yalnızca JSON çıktısı. Bir de açık talimat: “uzunluğa veya üsluba göre puan verme.”</p><p>En kritik adım ise şu: <strong>yargıcı da doğrulayın.</strong> 50–200 örneği insanlara puanlatın, yargıcın insanlarla uyumunu (Cohen’s kappa veya Spearman korelasyonu) ölçün. Uyum düşükse rubriği netleştirin. Yargıç modelini ve prompt’unu sürümleyip sabit tutun.</p><h3>İnsan değerlendirmesi: hâlâ altın standart</h3><p>Açık uçlu görevlerde, üslup ve faydalılıkta, tıp-hukuk gibi uzmanlık gerektiren alanlarda insan vazgeçilmez. Ama kendi gürültüsü de var. İyi bir kurgu için net yönergeler, örnek puanlanmış cevaplar, <strong>kör değerlendirme</strong> (hangi modelin yazdığı gizli) ve her örneğin birden fazla kişi tarafından puanlanması gerekir.</p><p>Puanlayıcıların birbiriyle uyumu <strong>Cohen’s kappa</strong> ile ölçülür: şans eseri beklenenin ötesinde ne kadar anlaşıyorlar? Kabaca 0.6 üzeri iyi, 0.8 üzeri çok iyi sayılır. Uyum düşükse çoğu zaman sorun puanlayıcılarda değil, görevin veya yönergenin belirsizliğindedir.</p><p>LMArena gibi platformlar kullanıcılara iki anonim modelin cevabını gösterip tercih toplar, sonra Bradley–Terry modeliyle her modele bir güç puanı hesaplar. Pratik bir kural: <strong>100 puanlık Elo farkı yaklaşık %64 kazanma olasılığına</strong> denk gelir. Puanlar her zaman güven aralığıyla birlikte okunmalı.</p><h3>RAG: iki ayrı sistemi ayrı ayrı ölçün</h3><p>Erişim destekli üretimde aslında iki sistem çalışır: bulucu ve üretici. Cevap yanlışsa suçlu hangisi? Bunu bilmek için ikisini ayrı ölçersiniz.</p><p><strong>Bulucu tarafı:</strong></p><ul><li><em>Context precision:</em> Getirilen parçaların ne kadarı gerçekten ilgili, ilgili olanlar üstte mi?</li><li><em>Context recall:</em> Cevap için gereken bilginin tamamı getirilenlerde var mı?</li></ul><p><strong>Üretici tarafı:</strong></p><ul><li><em>Faithfulness (sadakat):</em> Cevaptaki her iddia bağlamla destekleniyor mu? Halüsinasyonun doğrudan ölçüsüdür. Cevap atomik iddialara bölünür, her iddianın bağlamdan çıkarılıp çıkarılamayacağı bir LLM’e sorulur, desteklenenlerin oranı hesaplanır.</li><li><em>Answer relevance:</em> Cevap sorulan soruya gerçekten yanıt veriyor mu?</li></ul><p>Klasik erişim metrikleri (Recall@k, MRR, nDCG) de burada işe yarar.</p><p><strong>Hata ayıklama ipucu:</strong> Cevap yanlışsa önce context recall’a bakın. Bilgi hiç getirilmediyse sorun üreticide değil, bulucudadır: parçalama, gömme modeli, sorgu yeniden yazma.</p><h3>Ajanlar: sonuca değil, yolculuğa bakın</h3><p>Araç kullanan, çok adımlı çalışan sistemlerde tek bir cevabı değil, bütün yörüngeyi ölçersiniz:</p><ul><li><strong>Görev başarısı:</strong> Son durum doğru mu? Testler geçti mi, veritabanı beklenen hale geldi mi? En önemli metrik budur.</li><li><strong>Yörünge kalitesi:</strong> Gereksiz adım, döngü, tekrar eden hatalı araç çağrısı var mı?</li><li><strong>Araç çağrısı doğruluğu:</strong> Doğru araç, doğru parametrelerle mi çağrıldı?</li><li><strong>Maliyet ve gecikme:</strong> Görev başına token, dolar ve saniye. Başarı oranıyla birlikte raporlanmalı.</li><li><strong>Güvenli davranış:</strong> Geri alınamaz işlemlerden önce onay istiyor mu? Yetkisini aşıyor mu?</li></ul><p>Ve en ilginç metrik: <strong>pass^k.</strong> pass@k “k denemeden biri başarılıysa yeter” der, pass^k ise “k denemenin hepsi başarılı olmalı”. Üretimde kullanıcı şanslı denemeyi değil, her seferki davranışı görür. Bu yüzden pass^k çok daha dürüst bir ölçüdür.</p><p>Öne çıkan ortamlar: SWE-bench (yazılım), τ-bench (müşteri hizmetleri), WebArena ve BrowseComp (web), OSWorld (masaüstü), Terminal-Bench (komut satırı), GAIA (genel asistan). Ajan testleri yüksek varyanslıdır. Her görevi birden çok kez çalıştırın ve ortamın deterministik olarak sıfırlandığından emin olun.</p><h3>Güvenlik: “ne kadar iyi” kadar “ne kadar güvenli”</h3><p>Burada altın kural şu: <strong>zararlılık ile aşırı reddetmeyi birlikte ölçün.</strong> Her şeyi reddeden model güvenlik testinde mükemmel görünür ama kimsenin işine yaramaz.</p><p>Bakılacak başlıca boyutlar:</p><ul><li><strong>Zararlılık:</strong> Zararlı isteklere uyma oranı (HarmBench, AdvBench)</li><li><strong>Aşırı reddetme:</strong> Zararsız isteği reddetme (XSTest, OR-Bench)</li><li><strong>Jailbreak direnci:</strong> Saldırgan prompt’larla korumaları aşma başarısı</li><li><strong>Prompt injection:</strong> Araç çıktısındaki gizli talimatlara uyma (AgentDojo, InjecAgent)</li><li><strong>Önyargı ve toksisite:</strong> BBQ, BOLD, RealToxicityPrompts</li><li><strong>Halüsinasyon:</strong> SimpleQA, FActScore</li><li><strong>Dalkavukluk:</strong> Kullanıcı itiraz edince doğru cevabı değiştirme</li></ul><p>Statik veri setlerinin kaçırdığı riskleri ise <strong>red teaming</strong>, yani insan uzmanların veya otomatik saldırgan modellerin sistematik olarak açık aramasıyla bulursunuz.</p><h3>Altı klasik tuzak</h3><ol><li><strong>Veri kirlenmesi:</strong> Test soruları eğitime sızmışsa model ezberden cevaplar. Çözüm: tarihli, gizli veya sürekli yenilenen setler.</li><li><strong>Benchmark doygunluğu:</strong> Herkes %90+ alıyorsa küçük farklar anlam taşımaz.</li><li><strong>Prompt hassasiyeti:</strong> Şablon, seçenek sırası, few-shot sayısı skoru birkaç puan oynatabilir. Prompt’u sabitleyin, birkaç varyantla ölçün.</li><li><strong>Goodhart yasası:</strong> Ölçüt hedef olunca iyi ölçüt olmaktan çıkar. Tek metriği optimize etmek ölçülmeyen kaliteyi bozar.</li><li><strong>Cevap ayrıştırma hataları:</strong> Model doğru cevabı verir ama parsing kodunuz yakalayamaz ve yanlış sayılır. Hataların bir kısmını mutlaka elle inceleyin.</li><li><strong>Dağılım uyuşmazlığı:</strong> Genel benchmark’ta başarılı olmak, sizin alanınızda başarılı olmak demek değildir.</li></ol><h3>İstatistik: o iki puanlık fark gerçek mi?</h3><p>Değerlendirme seti bir örneklemdir, skor da bir tahmindir. Doğruluk p, örnek sayısı n ise standart hata yaklaşık √(p(1−p)/n), %95 güven aralığı da p ± 1.96 · SE olur.</p><p>Somutlaştırayım: <strong>200 soruluk bir sette %78&#39;lik skorun aralığı kabaca ±6 puan.</strong> Yani başa dönersek, %78 ile %76 arasındaki fark büyük ihtimalle şanstan ibaret.</p><p>Pratik kurallar:</p><ul><li>Skorları <strong>güven aralığıyla</strong> raporlayın. Küçük örneklemde Wilson aralığı normal yaklaşımdan daha güvenilirdir.</li><li>İki modeli aynı sorularda <strong>eşleştirilmiş</strong> karşılaştırın (eşleştirilmiş bootstrap, McNemar). Varyans belirgin şekilde düşer.</li><li>Aynı metinden türeyen sorular bağımsız değildir, <strong>kümelenmiş standart hata</strong> kullanın.</li><li>Temperature sıfırdan büyükse her soruyu birkaç kez çalıştırıp ortalama alın.</li><li>Onlarca alt kategoriye bakıyorsanız bazıları şans eseri “anlamlı” çıkar (<strong>çoklu karşılaştırma</strong>).</li></ul><p>Kaç örnek yeterli? Yakalamak istediğiniz farka bağlı: 5 puanlık farkı görmek için birkaç yüz, 1–2 puanlık farklar için birkaç bin örnek gerekir.</p><h3>Son söz</h3><p>LLM değerlendirmesi “bir skor bul, rapora yaz” işi değil. Kendi verinizle, güven aralıklarıyla, hataları elle inceleyerek ve her değişiklikte yeniden ölçerek yürüttüğünüz sürekli bir pratik. Genel benchmark’lar ilk elemede işe yarar, ama nihai kararı kendi değerlendirme setiniz verir.</p><p>İyi haber şu: yüzlerce örnek, net bir rubrik ve biraz disiplinle, çoğu ekibin bugün yaptığından çok daha sağlam bir sistem kurulabilir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65bc695c920a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LLM Fine-Tuning Rehberi: Full Fine-Tuning’den PEFT, LoRA ve QLoRA’ya]]></title>
            <link>https://medium.com/@eren.alltun/llm-fine-tuning-rehberi-full-fine-tuningden-peft-lora-ve-qlora-ya-ae9caba80344?source=rss-a95e2cc08f44------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae9caba80344</guid>
            <dc:creator><![CDATA[Eren ALTUN]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 16:41:37 GMT</pubDate>
            <atom:updated>2026-11-09T16:41:37.407Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Büyük dil modellerini kendi verinize uyarlamanın yolları: neden full fine-tuning pahalı, PEFT ailesi nasıl çalışıyor, LoRA’nın matematiği, QLoRA’nın 4-bit hileleri ve SFT’den DPO’ya hizalama zinciri.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z-B8_U68D0THH5-qWgxOsQ.jpeg" /></figure><p>Bir dil modelini kendi işinize uyarlamak istediğinizde karşınıza hemen bir yığın kısaltma çıkıyor: SFT, PEFT, LoRA, QLoRA, DoRA, DPO, GRPO… Hepsi aynı problemin farklı yüzlerine bakıyor ve birbirleriyle karıştırılması çok kolay. Bu yazıda tabloyu baştan sona, sırasıyla ve mümkün olduğunca sezgisel biçimde çiziyorum: fine-tuning nedir, neden pahalıdır, PEFT bu pahalılığı nasıl aşar, LoRA ve QLoRA içeride ne yapar, hangi yöntemi ne zaman seçmelisiniz ve eğitimde hangi hatalar sizi bekliyor.</p><p>Yazının sonunda çalışır kod örnekleri, bir karar rehberi ve pratik ipuçları listesi var. Acelesi olan doğrudan “Hangi yöntemi seçmeli?” bölümüne atlayabilir.</p><h3>1. Fine-tuning nedir ve ne işe yarar?</h3><p>Pre-Training (Ön eğitim) yapay zeka ve makine öğrenimi modellerinin (özellikle büyük dil modellerinin), herhangi bir özel göreve odaklanmadan önce çok büyük ve genel veri setleri üzerinde ham bilgiyi, dilbilgisi yapılarını ve dünya hakkındaki temel kalıpları öğrendiği ilk ve en temel eğitim aşamasıdır, Buradan çıkıp kullandığımız modele base model deriz.</p><p>Fine-tuning, bu önceden eğitilmiş ağırlıkları başlangıç noktası alıp çok daha küçük ve göreve özel bir veri setiyle eğitime devam etmektir. Tipik amaçlar dört başlıkta toplanır:</p><ul><li><strong>Görev uyarlama:</strong> Sınıflandırma, bilgi çıkarma, SQL üretimi, özetleme gibi dar bir görevde başarımı artırmak.</li><li><strong>Stil ve format:</strong> Belirli bir ton, JSON şeması, kurumsal dil ya da karakter kişiliği öğretmek.</li><li><strong>Alan uyarlama:</strong> Tıp, hukuk, finans gibi alanların jargonunu ve kalıplarını içselleştirmek.</li><li><strong>Hizalama:</strong> Talimat takibi (instruction tuning), tercihlere uyum (RLHF/DPO) ve güvenlik davranışları.</li></ul><p><strong>Önemli ayrım:</strong> Fine-tuning modele <em>davranış ve format</em> öğretmekte çok iyidir. Ancak sürekli değişen gerçek bilgiyi (örneğin güncel ürün kataloğunuzu) eklemek için genellikle RAG (retrieval-augmented generation) hem daha uygun hem daha ucuzdur. İkisi sıklıkla birlikte kullanılır.</p><p>Bu yüzden fine-tuning’e başlamadan önce kendinize şunu sormalısınız: İyi yazılmış bir prompt, birkaç örnek (few-shot) veya RAG problemimi zaten çözüyor mu? Çözüyorsa fine-tuning’e hiç gerek olmayabilir.</p><h3>2. Full fine-tuning ve bellek problemi</h3><p>Full fine-tuning’de modelin <strong>tüm parametreleri</strong> güncellenir. En esnek ve genellikle en yüksek tavanlı yöntemdir; fakat bellek maliyeti parametre sayısının çok ötesine geçer. Adam optimizer ve karışık hassasiyet (mixed precision) kullanıldığında parametre başına bellek dökümü şöyledir:</p><ul><li>Model ağırlıkları (bf16): 2 byte</li><li>Gradyanlar (bf16): 2 byte</li><li>Adam momentum, m (fp32): 4 byte</li><li>Adam varyans, v (fp32): 4 byte</li><li>fp32 master ağırlıklar: 4 byte</li><li><strong>Toplam (aktivasyonlar hariç): yaklaşık 16 byte/parametre</strong></li></ul><p>Yani 7 milyar parametreli bir model için yalnızca ağırlık, gradyan ve optimizer durumu yaklaşık <strong>112 GB</strong> eder. Üstüne aktivasyonlar ve batch boyutu biner. Bu, tek bir tüketici GPU’sunun çok ötesindedir ve DeepSpeed ZeRO ya da FSDP gibi dağıtık stratejilerle çoklu GPU gerektirir.</p><p>Bellek tek sorun değil:</p><ul><li><strong>Depolama:</strong> Her görev için modelin tam bir kopyasını (7B için bf16&#39;da yaklaşık 14 GB) saklamanız gerekir.</li><li><strong>Catastrophic forgetting:</strong> Küçük bir veriyle tüm ağırlıkları oynatmak, modelin genel yeteneklerini bozabilir.</li><li><strong>Overfitting riski:</strong> Az veride çok sayıda serbest parametre ezberlemeye yatkındır.</li></ul><p>İşte PEFT tam olarak bu sorunlara cevap olarak doğdu.</p><h3>3. PEFT: Parametre-verimli fine-tuning</h3><p>PEFT (Parameter-Efficient Fine-Tuning), base modelin ağırlıklarının büyük çoğunluğunu, çoğu zaman tamamını dondurup yalnızca çok küçük bir parametre kümesini eğiten yöntemlerin genel adıdır. Eğitilen parametre oranı tipik olarak <strong>%0,01 ile %1</strong> arasındadır. Sonuçları şunlar:</p><ul><li>Gradyan ve optimizer durumu yalnızca küçük parametre kümesi için tutulur, dolayısıyla bellek dramatik biçimde düşer.</li><li>Her görev için yalnızca birkaç MB’lık bir “adapter” dosyası saklanır. Tek bir base model ve çok sayıda adapter mümkündür.</li><li>Base model korunduğu için unutma daha sınırlı olur.</li><li>Az veride daha stabildir ve birçok görevde full FT’ye çok yakın sonuç verir.</li></ul><h3>PEFT taksonomisi</h3><p>Yöntemler, neyi eğittiklerine göre dört ana gruba ayrılır:</p><ul><li><strong>Eklemeli (additive):</strong> Modele yeni, küçük eğitilebilir modüller ya da vektörler eklenir. Örnekler: Adapters, Prefix Tuning, Prompt Tuning, P-Tuning, (IA)³.</li><li><strong>Seçici (selective):</strong> Mevcut parametrelerin küçük bir alt kümesi eğitilir. Örnekler: BitFit, yalnızca son katmanlar, yalnızca LayerNorm.</li><li><strong>Yeniden parametreleme:</strong> Ağırlık güncellemesi düşük boyutlu bir temsille ifade edilir. Örnekler: LoRA, QLoRA, DoRA, AdaLoRA, VeRA, LoHa, LoKr.</li><li><strong>Hibrit:</strong> Birden fazla yaklaşımın birleşimi. Örnekler: UniPELT, MAM Adapter, Compacter.</li></ul><p>Hugging Face’in peft kütüphanesi bu yöntemlerin çoğunu ortak bir API ile sunar: bir XxxConfig oluşturur, get_peft_model(model, config) ile modeli sarmalarsınız. Bu kadar.</p><h3>4. LoRA: Low-Rank Adaptation</h3><p>Hu ve arkadaşlarının (Microsoft, 2021) önerdiği LoRA, bugün en yaygın kullanılan PEFT yöntemi.</p><p><strong>Temel sezgi:</strong> Önceden eğitilmiş bir modeli yeni bir göreve uyarlarken ağırlıklarda gereken değişim (ΔW) tam boyutlu bir matris olsa da aslında düşük bir “intrinsic rank”e sahiptir. Başka bir deyişle, ΔW’yi iki küçük matrisin çarpımıyla iyi bir şekilde yaklaşıklayabiliriz.</p><h3>Sade anlatım: LoRA bir “yama” gibidir</h3><p>Formüllere geçmeden önce fikri günlük dille anlatayım. Matematik kısmı bu fikrin sadece düzgün yazılmış hali.</p><p><strong>1. Model aslında dev bir sayı tablosu.</strong> Modelin her katmanı, W₀ adında büyük bir sayı tablosundan (matristen) oluşur. Örneğin 4096 satır ve 4096 sütunluk bir tablo düşünün: 16 milyondan fazla sayı. Full fine-tuning’de bu sayıların hepsini tek tek değiştirirsiniz, bu yüzden hem bellek hem hesaplama çok pahalıdır.</p><p><strong>2. LoRA’nın gözlemi: değişiklik aslında “basit”.</strong> Araştırmacılar şunu fark etti: Modeli yeni bir göreve uyarlarken 16 milyon sayının her biri bağımsız ve rastgele değişmiyor. Değişiklik düzenli bir desene sahip, bu yüzden onu çok daha az sayıyla ifade edebiliyoruz. Buna “düşük rank” deniyor.</p><p>Küçük bir örnek verelim. 4×4&#39;lük, yani 16 sayılık şu tabloya bakın:</p><pre>1  0  2  1<br>2  0  4  2<br>3  0  6  3<br>4  0  8  4</pre><p>Bu 16 sayıyı tek tek ezberlemeye gerek yok. Sadece iki küçük liste yeter:</p><ul><li>Dikey liste (B): 1, 2, 3, 4</li><li>Yatay liste (A): 1, 0, 2, 1</li></ul><p>Dikey listenin her elemanını yatay listeyle çarparsanız tablonun tamamı çıkar. Yani 16 sayıyı toplam 4 + 4 = 8 sayıyla ifade ettik. Tablo büyüdükçe tasarruf muazzam olur: 4096×4096&#39;lık bir tabloda listelerin uzunluğunu 16 gibi küçük bir sayıyla sınırlarsak (bu sayıya <strong>r</strong>, yani rank diyoruz), 16 milyon sayı yerine yalnızca 131 bin sayıyı eğitmemiz yeter. Bu, tablonun yüzde 1&#39;inin altına denk gelir.</p><p><strong>3. LoRA’da ne yapılıyor?</strong></p><ul><li>Orijinal büyük tablo (W₀) <strong>dondurulur</strong>, hiç dokunulmaz.</li><li>Yanına iki küçük tablo eklenir: A ve B.</li><li>Sadece bu ikisi eğitilir.</li><li>Model bir girdi gördüğünde iki yoldan hesap yapar: biri orijinal tablodan, biri A ve B’den geçer. Sonra ikisinin sonucu toplanır.</li></ul><p>Yani kabaca “orijinal cevap + küçük düzeltme” işlemi yapılır. Aşağıdaki formüldeki h = W₀·x + (α/r)·B·(A·x) tam olarak bunu söyler.</p><p><strong>4. α/r nedir?</strong> Küçük düzeltmenin ne kadar güçlü etki edeceğini ayarlayan bir ses düğmesi gibi düşünün. α sizin seçtiğiniz bir sayıdır. r ile bölünmesinin sebebi, rank’ı değiştirdiğinizde düzeltmenin gücünün kontrolsüzce değişmemesidir.</p><p><strong>5. Neden B sıfırla başlıyor?</strong> Eğitimin başında B’nin tamamı sıfır olduğu için B·A de sıfırdır. Yani “düzeltme” henüz yoktur ve model tam olarak orijinal haliyle çalışır. Eğitim ilerledikçe A ve B öğrenir, düzeltme yavaş yavaş devreye girer. Model baştan bozulmaz, bu da eğitimi kararlı yapar.</p><p><strong>Tek cümlelik özet:</strong> Modeli yeniden yazmak yerine ona çok küçük bir yama ekliyorsunuz; yama küçük olduğu için bellek ve depolama ucuz, ama sonuç çoğu zaman tam eğitimle yarışıyor.</p><p>İsterseniz şimdi aynı fikrin formülle gösterimine bakalım.</p><h3>Matematik</h3><p>Ağırlığı W₀ ∈ ℝ^(d×k) olan bir lineer katman için LoRA, W₀’ı dondurur ve güncellemeyi şöyle yazar:</p><pre>W = W₀ + ΔW = W₀ + (α / r) · B·A<br>B ∈ ℝ^(d×r),  A ∈ ℝ^(r×k),  r ≪ min(d, k)<br><br>h = W₀·x + (α / r) · B·(A·x)</pre><p>Yani giriş x, donmuş W₀’dan geçerken paralel bir yoldan da A (rank r’ye indirger) ve B (tekrar d boyutuna çıkarır) matrislerinden geçer. Bu ikinci yolun çıktısı α/r ile ölçeklenip ana yolun çıktısına eklenir. Sadece A ve B eğitilir.</p><h3>Başlatma</h3><p>A rastgele (Kaiming/Gaussian) başlatılır, <strong>B sıfırla</strong> başlatılır. Böylece eğitimin başında B·A = 0 olur ve model birebir base model gibi davranır. Eğitim “sıfır değişiklikten” başlar; bu, kararlılık açısından zarif bir tasarım.</p><h3>Neden bu kadar verimli?</h3><p>d = k = 4096 ve r = 16 olan tek bir katmanı düşünün:</p><pre>Full:  4096 × 4096        = 16.777.216 parametre<br>LoRA:  16 × (4096 + 4096) =    131.072 parametre  (%0,78)</pre><p>Orijinal makalede GPT-3 175B üzerinde eğitilebilir parametre sayısı yaklaşık 10.000 kat, GPU bellek ihtiyacı yaklaşık 3 kat azaltılmış; kalite ise full fine-tuning’e eşit ya da daha iyi raporlanmıştır.</p><h3>Merge ve sıfır çıkarım gecikmesi</h3><p>Eğitim bittikten sonra W = W₀ + (α/r)·B·A hesaplanıp tek bir matrise yazılabilir (merge_and_unload()). Bu durumda çıkarımda <strong>hiç ek gecikme olmaz</strong>; bu, klasik adapter yöntemlerine göre büyük bir avantaj. Alternatif olarak adapter&#39;ı ayrı tutup çalışma zamanında farklı görevler arasında hızla geçiş yapabilirsiniz (örneğin vLLM ya da LoRAX ile multi-LoRA serving).</p><h3>Hiperparametreler</h3><p>LoRA’nın birkaç temel düğmesi var ve hangisinin ne işe yaradığını bilmek çoğu zaman başarılı eğitimle boşa giden bir gün arasındaki farktır:</p><ul><li><strong>r (rank):</strong> Düşük-rank matrislerin iç boyutu, yani kapasite. Tipik aralık 8–64. Basit stil ve format işleri için 8–16, karmaşık görev, yeni dil ya da çok veri için 32–128.</li><li><strong>lora_alpha:</strong> Ölçekleme faktörü; güncelleme α/r ile çarpılır. Genelde α = r ya da α = 2r seçilir. r’yi değiştirdiğinizde öğrenme hızını yeniden ayarlamak istemiyorsanız α/r oranını sabit tutun.</li><li><strong>target_modules:</strong> LoRA’nın ekleneceği katmanlar. Orijinal makale yalnızca q ve v projeksiyonlarını kullanır; pratikte en iyi sonuç çoğunlukla tüm lineer katmanlarla (q, k, v, o, gate, up, down) gelir: &quot;all-linear&quot;.</li><li><strong>lora_dropout:</strong> LoRA yolundaki dropout, 0–0,1 arası. Küçük veride 0,05–0,1.</li><li><strong>Öğrenme hızı:</strong> LoRA, full FT’den daha yüksek LR ister: 1e-4 ile 3e-4 arası. Full FT’de tipik değer 1e-5 ile 2e-5 arasındadır.</li><li><strong>bias:</strong> Bias’ların eğitilip eğitilmeyeceği; genellikle &quot;none&quot;.</li><li><strong>modules_to_save:</strong> Tamamen eğitilecek ek modüller. Yeni token eklediyseniz embed_tokens ve lm_head burada olmalı.</li></ul><blockquote><strong><em>Dikkat:</em></strong><em> Standart LoRA’da ölçek α/r olduğundan, α sabitken r’yi büyütmek güncellemenin etkisini küçültür. Yüksek rank’larda bu öğrenmeyi yavaşlatabilir. Bu sorunu aşağıda göreceğimiz rsLoRA çözüyor.</em></blockquote><h3>5. QLoRA: Base model 4-bit olunca</h3><p>LoRA eğitilen parametreleri küçültür ama donmuş base modelin kendisi hâlâ bf16&#39;da, yani parametre başına 2 byte olarak bellekte durur. 70B’lik bir model yalnızca ağırlıkları için yaklaşık 140 GB ister. Dettmers ve arkadaşlarının (2023) QLoRA’sı bu duvarı şu fikirle aşar: <strong>base modeli 4-bit’e kuantize edip dondur, LoRA adapter’larını ise bf16&#39;da eğit.</strong></p><p>İleri ve geri geçiş sırasında 4-bit ağırlıklar anlık olarak bf16&#39;ya dequantize edilir; gradyanlar 4-bit ağırlıklar üzerinden LoRA matrislerine akar. Makale, 65B parametreli bir modelin tek bir 48 GB’lık GPU’da fine-tune edilebildiğini ve 16-bit full fine-tuning kalitesinin korunduğunu gösterdi (Guanaco modelleri).</p><p>QLoRA’yı mümkün kılan üç yenilik var.</p><h3>1) NF4 (4-bit NormalFloat)</h3><p>Önceden eğitilmiş ağırlıklar yaklaşık olarak sıfır merkezli normal dağılıma uyar. NF4, 16 kuantizasyon seviyesini standart normal dağılımın kantillerine yerleştirir; böylece her seviyeye yaklaşık eşit sayıda ağırlık düşer. Normal dağılan veri için bilgi-teorik olarak en uygun 4-bit veri tipidir ve FP4 ya da Int4&#39;ten daha iyi sonuç verir. Kuantizasyon blok bazlıdır (örneğin 64 ağırlıklık bloklar) ve her blok kendi absmax ölçek sabitiyle normalize edilir.</p><h3>2) Double Quantization</h3><p>Her 64 ağırlık için bir fp32 ölçek sabiti tutmak, parametre başına yaklaşık 0,5 bit ek yük demektir. Double quantization bu sabitleri de kuantize eder (8-bit, 256&#39;lık bloklar halinde). Ek yük yaklaşık 0,127 bit/parametreye iner; 65B bir modelde bu, kabaca 3 GB tasarruf demek.</p><h3>3) Paged Optimizers</h3><p>Uzun diziler veya gradient checkpointing sırasında oluşan ani bellek tepeleri OOM hatalarına yol açar. Paged optimizer’lar NVIDIA unified memory kullanarak optimizer durumlarını gerektiğinde otomatik olarak CPU RAM’e sayfalar, sonra geri getirir.</p><p>Kaba bir bellek formülü şöyle:</p><pre>Bellek ≈ (Toplam param × ~0,52 byte) + (LoRA param × ~16 byte) + aktivasyonlar</pre><h3>QLoRA’nın bedeli</h3><p>Bedava öğle yemeği yok:</p><ul><li><strong>Daha yavaş:</strong> Her ileri/geri geçişte dequantize işlemi yapıldığı için LoRA’ya kıyasla tipik olarak %20–40 daha yavaş eğitim.</li><li><strong>Küçük kalite farkı:</strong> Çoğu görevde ihmal edilebilir düzeydedir ama kuantizasyon hatası nedeniyle LoRA’nın biraz gerisinde kalabilir. LoftQ bunu azaltmayı hedefler.</li><li><strong>Merge dikkat ister:</strong> Adapter’ı 4-bit modele doğrudan merge etmek kalite kaybettirir. Doğru yol, base modeli bf16&#39;da yükleyip adapter’ı onun üzerine merge etmektir.</li></ul><h3>Ne öğretiyoruz? SFT, RLHF, DPO ve diğerleri</h3><p>Burada çoğu kişinin kafasının karıştığı ince bir ayrım var. LoRA ve QLoRA <strong>nasıl eğittiğinizi</strong> belirler: hangi parametreler güncellenir, ne kadar bellek kullanılır. <strong>Ne öğrettiğiniz</strong> ise eğitim hedefiyle belirlenir. Bu ikisi birbirinden bağımsızdır; örneğin “QLoRA ile DPO” çok yaygın bir kombinasyondur.</p><p>Tipik hat şöyle ilerler: <strong>Pre-training</strong> (ham metin, base model) → <strong>SFT / Instruction tuning</strong> (talimat → cevap çiftleri) → <strong>Tercih ve RL aşaması</strong> (RLHF, DPO, GRPO).</p><p><strong>Önce önemli bir netleştirme:</strong> Pre-training, SFT, RLHF, DPO gibi terimler ayrı modeller değildir. Bunlar, <strong>aynı modelin ağırlıkları üzerinde art arda uygulanan eğitim aşamalarının</strong> adıdır. Her aşama bir öncekinin çıktısını başlangıç noktası alır ve aynı modeli biraz daha değiştirir. Yani baştan sona tek bir model vardır; sadece ona farklı türde veri ve farklı bir eğitim hedefiyle birkaç kez eğitim yaptırılır.</p><p><strong>1. Pre-training (ön eğitim).</strong> Model, internetten toplanmış devasa miktarda ham metin üzerinde yalnızca “sonraki kelimeyi tahmin et” görevini yapar. Sonunda dili ve dünya bilgisini öğrenmiş bir <em>base model</em> elde edilir. Ancak bu model soru-cevap için eğitilmediği için, bir soruya cevap vermek yerine soruyu devam ettirebilir.</p><p><strong>2. SFT (Supervised Fine-Tuning, denetimli ince ayar).</strong> Bu aşamada modele (soru, doğru cevap) çiftleri gösterilir ve model bu cevapları üretmeyi öğrenir. Eğitim yine “sonraki kelimeyi tahmin et” mantığıyla yapılır, ama bu kez veri hazırlanmış soru-cevap örnekleridir ve kayıp genellikle yalnızca cevap kısmında hesaplanır. Sonuçta model talimat takip etmeyi öğrenir. Bu yüzden hemen her şeyin ilk adımı SFT’dir. Instruction tuning de SFT’nin bir türüdür.</p><p><strong>3. Tercih aşaması (hizalama).</strong> SFT’den sonra model talimatlara uyuyordur ama cevaplarının <em>kalitesi</em> her zaman istediğiniz gibi olmayabilir: fazla uzun, yanlış tonda ya da zararlı olabilir. Bu aşamada modele “şu cevap, şu cevaptan daha iyi” bilgisi verilir. Aşağıdaki yöntemlerin hepsi bu aşamanın alternatifleridir, yani genellikle birini seçersiniz:</p><ul><li><strong>RLHF (PPO):</strong> En eski yöntem ve üç adımdan oluşur. Önce insanlar aynı soruya verilmiş iki cevaptan iyisini seçer. Bu seçimlerden, cevaba puan veren ayrı bir yardımcı model (ödül modeli) eğitilir. Son olarak asıl model, bu puanı yükseltecek şekilde (PPO algoritmasıyla) güncellenir; bu sırada modelin eski halinden çok uzaklaşmaması için bir ceza (KL cezası) uygulanır. Burada gerçekten birden fazla model vardır: eğitilen model, eski hali (referans), ödül modeli ve PPO’nun değer modeli. Hepsinin aynı anda bellekte durması gerektiği için yöntem güçlü ama karmaşık, kararsız ve pahalıdır.</li><li><strong>DPO (Direct Preference Optimization):</strong> RLHF ile aynı tür veriyi kullanır (soru, tercih edilen cevap, reddedilen cevap) ama ödül modelini ve pekiştirmeli öğrenme döngüsünü tamamen atlar. Model, tercih edilen cevabın olasılığını artıracak, reddedilenin olasılığını azaltacak şekilde doğrudan eğitilir. Eski halini referans olarak ister. Basit ve kararlı olduğu için açık modellerde çok yaygındır.</li><li><strong>ORPO:</strong> SFT’yi ve tercih öğrenmeyi tek aşamada birleştirir. Ayrı bir referans model gerektirmez, bu yüzden daha az bellek kullanır.</li><li><strong>KTO:</strong> DPO’da her örnek için iki cevap (iyi ve kötü) gerekir. KTO’da ise tek bir cevap ve yanında “iyi” ya da “kötü” etiketi yeterlidir. Kullanıcıların verdiği beğen/beğenme geri bildirimleri gibi verilerle çalışmak için uygundur.</li><li><strong>GRPO:</strong> Doğruluğu otomatik kontrol edilebilen görevlerde (matematik sorusunun cevabı doğru mu, yazılan kod testleri geçiyor mu) kullanılır. Model her soru için bir grup cevap üretir, her cevap kontrol edilip puanlanır ve grubun ortalamasından iyi olan cevaplar güçlendirilir. Ayrı bir puanlayıcı ya da değer modeli gerekmez. “Adım adım düşünen” modellerin eğitiminde sık kullanılır.</li></ul><p>Hugging Face TRL kütüphanesi bunların hepsi için hazır trainer’lar sunar (SFTTrainer, DPOTrainer, ORPOTrainer, KTOTrainer, GRPOTrainer) ve hepsi peft_config parametresiyle LoRA/QLoRA ile çalışır.</p><blockquote><strong><em>LoRA + DPO bonusu:</em></strong><em> DPO normalde ayrı bir referans model kopyası ister. LoRA kullandığınızda referans model, adapter’ı geçici olarak devre dışı bırakılmış base modelin kendisidir. İkinci bir kopya gerekmez ve bellek yarıya iner.</em></blockquote><h3>Yöntemlerin kuşbakışı karşılaştırması</h3><p>Aşağıdaki özet, yöntemleri eğitilen parametre oranı, bellek ve çıkarım maliyeti açısından yan yana koyar. Kalite değerlendirmeleri göreve, veriye ve modele çok bağlı genel eğilimlerdir; kesin bir sıralama değildir.</p><ul><li><strong>Full FT:</strong> Parametrelerin %100&#39;ü eğitilir, bellek çok yüksektir, çıkarım yükü yoktur. Kalite en yüksek tavandadır. Büyük veri, büyük bütçe ve köklü değişim gerektiğinde uygundur.</li><li><strong>LoRA:</strong> Yaklaşık %0,1–1 parametre, orta bellek, merge ile sıfır çıkarım yükü. İyi kalite; varsayılan tercih.</li><li><strong>QLoRA:</strong> LoRA ile aynı parametre oranı, düşük bellek, bf16 base üzerinde merge ile sıfır yük. Kısıtlı GPU ve büyük model için ideal.</li><li><strong>DoRA:</strong> LoRA’ya ek küçük bir maliyet, merge sonrası yük yok. Düşük rank’ta LoRA’dan daha iyi kalite.</li><li><strong>AdaLoRA:</strong> Dinamik parametre bütçesi, orta bellek. Bütçe sınırlıysa verimli dağıtım sağlar.</li><li><strong>VeRA:</strong> %0,01&#39;in altında parametre. Binlerce adapter saklamak gerektiğinde ideal.</li><li><strong>Adapters:</strong> %0,5–5 parametre, seri katman nedeniyle çıkarımda ek yük. Modüler ve birleştirilebilir görevler için.</li><li><strong>Prefix / Prompt Tuning:</strong> Çok az parametre, düşük bellek; bağlam uzunluğunu tüketir. Prompt tuning çok büyük modellerde ve çok görevli serving’de anlamlıdır.</li><li><strong>(IA)³:</strong> Yaklaşık %0,01 parametre, çıkarım yükü yok. Few-shot ve çok az veri için.</li><li><strong>BitFit:</strong> Yaklaşık %0,1 parametre. Bias’lı modeller (BERT vb.) için.</li><li><strong>GaLore:</strong> Tüm parametreler eğitilir ama optimizer belleği düşer. Kısıtlı bellekle full-parametre öğrenme için.</li></ul><h3>Sonuç</h3><p>Özetle: Full fine-tuning güçlü ama pahalı. PEFT, modeli dondurup küçük bir parça eğiterek bu maliyeti birkaç büyüklük mertebesi aşağı çeker. LoRA bunu düşük-rank bir güncellemeyle, sıfır çıkarım gecikmesiyle yapar; QLoRA ise base modeli 4-bit’e indirerek devasa modelleri tek bir GPU’ya sığdırır. DoRA, rsLoRA, LoRA+ gibi varyantlar bu temelin üzerine kalite ve verimlilik ekler. Üstteki eğitim hedefi (SFT, DPO, GRPO…) ise “neyi öğrettiğinizi” belirler ve LoRA/QLoRA ile serbestçe birleştirilebilir.</p><p>Benim önerim basit: önce prompt ve RAG ile deneyin, sonra temiz bir veri setiyle LoRA/QLoRA’ya geçin, ölçümünüzü baştan kurun ve ancak gerçekten gerekirse daha egzotik yöntemlere bakın.</p><h3>Temel kaynaklar</h3><ul><li>Hu ve ark. (2021), <em>LoRA: Low-Rank Adaptation of Large Language Models</em>, arXiv:2106.09685</li><li>Dettmers ve ark. (2023), <em>QLoRA: Efficient Finetuning of Quantized LLMs</em>, arXiv:2305.14314</li><li>Liu ve ark. (2024), <em>DoRA: Weight-Decomposed Low-Rank Adaptation</em>, arXiv:2402.09353</li><li>Zhang ve ark. (2023), <em>AdaLoRA</em>, arXiv:2303.10512</li><li>Kalajdzievski (2023), <em>A Rank Stabilization Scaling Factor for Fine-Tuning with LoRA</em>, arXiv:2312.03732</li><li>Hayou ve ark. (2024), <em>LoRA+</em>, arXiv:2402.12354</li><li>Houlsby ve ark. (2019), <em>Parameter-Efficient Transfer Learning for NLP</em>, arXiv:1902.00751</li><li>Li &amp; Liang (2021), <em>Prefix-Tuning</em>, arXiv:2101.00190</li><li>Lester ve ark. (2021), <em>The Power of Scale for Parameter-Efficient Prompt Tuning</em>, arXiv:2104.08691</li><li>Liu ve ark. (2022), <em>Few-Shot Parameter-Efficient Fine-Tuning is Better and Cheaper than In-Context Learning</em>, arXiv:2205.05638</li><li>Rafailov ve ark. (2023), <em>Direct Preference Optimization</em>, arXiv:2305.18290</li><li>Zhao ve ark. (2024), <em>GaLore</em>, arXiv:2403.03507</li><li>Hugging Face dokümantasyonu: PEFT ve TRL</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae9caba80344" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LLM’lerde Kantizasyon: 70 Milyar Parametreyi Oyun Bilgisayarına Sığdırmanın Sanatı]]></title>
            <link>https://medium.com/@eren.alltun/llmlerde-kantizasyon-70-milyar-parametreyi-oyun-bilgisayar%C4%B1na-s%C4%B1%C4%9Fd%C4%B1rman%C4%B1n-sanat%C4%B1-1e20a13bfb0a?source=rss-a95e2cc08f44------2</link>
            <guid isPermaLink="false">https://medium.com/p/1e20a13bfb0a</guid>
            <dc:creator><![CDATA[Eren ALTUN]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 05:51:42 GMT</pubDate>
            <atom:updated>2026-11-09T05:51:42.834Z</atom:updated>
            <content:encoded><![CDATA[<p><em>FP32’den INT4’e: büyük dil modelleri nasıl küçülüyor, bu sırada ne kaybediyoruz ve hangi yöntemi seçmelisiniz?</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cniN9EpTxDGRpFpb8Fgn2g.jpeg" /></figure><p>Bir sabah 70 milyar parametreli bir modeli kendi bilgisayarınızda çalıştırmak istediğinizi düşünün. Model dosyasını indiriyorsunuz, yüklemeye çalışıyorsunuz ve ekranda tanıdık bir hata beliriyor: <em>CUDA out of memory</em>.</p><p>Sorun modelin “akıllı” olmasında değil, <strong>büyük</strong> olmasında. Ve bu sorunun en etkili çözümlerinden biri, modeli yeniden eğitmeden, sadece içindeki sayıları daha az bitle saklamak: <strong>kantizasyon (quantization)</strong>.</p><p>Bu yazıda kantizasyonu sıfırdan, ama yüzeysel kalmadan ele alacağız: neden gerekli olduğunu, matematiğini, GPTQ / AWQ / GGUF / NF4 gibi yöntemlerin farkını, kaliteden ne kadar ödün verdiğimizi ve pratikte nasıl uygulanacağını.</p><h3>1. Problem: Modeller çok büyük</h3><p>Bir LLM’in çalışabilmesi için tüm parametrelerinin (ağırlıklarının) belleğe yüklenmesi gerekir. Bir parametrenin kapladığı yer, onu hangi sayı formatında sakladığınıza bağlıdır:</p><ul><li>FP32: 4 bayt</li><li>FP16 / BF16: 2 bayt</li><li>INT8: 1 bayt</li><li>INT4: 0,5 bayt</li></ul><p>Basit bir çarpma, tablonun tamamını verir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/582/1*sEls4SF3tuMDgs3C3hph3A.png" /></figure><p>Bu rakamlar yalnızca <strong>ağırlıkların</strong> boyutu. Gerçek kullanımda üzerine aktivasyonlar ve KV cache (bölüm 8) da eklenir; yani tablodaki değerler alt sınırdır.</p><p>Tüketici ekran kartlarının çoğunda 8–24 GB VRAM bulunduğunu düşünürseniz, 7B’lik bir modelin FP16 hali bile orta seviye bir kartı zorlar; 70B’lik bir modelin FP16 hali ise tek GPU’ya hiç sığmaz.</p><h3>Kantizasyon sadece yer kazandırmaz</h3><p>Kantizasyonun faydası dört başlıkta toplanır:</p><ul><li><strong>Bellek:</strong> Model daha küçük donanıma sığar.</li><li><strong>Hız:</strong> LLM çıkarımının (inference) metin üretme aşaması çoğunlukla hesaplama değil <strong>bellek bant genişliği</strong> ile sınırlıdır. Her yeni token için ağırlıkların büyük kısmı bellekten okunur. Ağırlıklar ne kadar küçükse okuma o kadar hızlı biter. Düşük hassasiyetli aritmetik, destekleyen donanımda ek hız da sağlar; kazancın büyüklüğü donanıma ve kullanılan kernel’e bağlıdır.</li><li><strong>Enerji:</strong> Daha az veri taşımak daha az enerji demektir. Telefon ve gömülü cihazlar için kritik bir faktördür.</li><li><strong>Erişilebilirlik:</strong> 4-bit kantizasyonla büyük modeller, tek bir gaming GPU’sunda ya da sıradan bir laptopta çalıştırılabilir hale gelir.</li></ul><h3>2. Kantizasyon nedir?</h3><p>Kantizasyon, geniş bir sayı aralığını (örneğin float32) daha az bit kullanan, daha dar bir temsile dönüştürmektir. Bu dönüşümde bir miktar bilgi kaybı kaçınılmazdır. En yakın benzetme, bir fotoğrafı JPEG’e sıkıştırmaktır: dosya küçülür, çoğu zaman farkı göremezsiniz, ama aşırı sıkıştırırsanız bozulmalar belirginleşir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/762/1*UXhPWrMw11Xxp_gIVxSU1w.png" /></figure><p>BF16 ile FP16 arasındaki fark önemlidir: BF16, FP32 ile aynı sayı <strong>aralığını</strong> korur ama hassasiyetten ödün verir. Bu yüzden eğitimde ve çıkarımda geniş çapta tercih edilir. INT8 ve INT4 ise ondalık kısmı tamamen bırakıp ağırlığı sınırlı sayıda “seviyeye” indirir: 8 bitle 256, 4 bitle yalnızca 16 farklı değer.</p><h3>Temel formül</h3><p>Kantizasyonun çekirdeğinde iki sayı vardır: bir <strong>ölçek (scale)</strong> ve gerekirse bir <strong>sıfır noktası (zero point)</strong>.</p><h4><strong>Simetrik kantizasyon</strong> (sıfır etrafında simetrik aralık):</h4><pre>scale     = max(|W|) / (2^(n-1) - 1)<br>W_int     = round(W / scale)<br>W_dequant = W_int * scale</pre><h4><strong>Asimetrik (affine) kantizasyon</strong> (aralık simetrik değilse):</h4><pre>scale      = (max(W) - min(W)) / (2^n - 1)<br>zero_point = round(-min(W) / scale)<br>W_int      = round(W / scale) + zero_point<br>W_dequant  = (W_int - zero_point) * scale</pre><h3>Küçük bir örnek</h3><p>Dört ağırlığımız olsun: [0.42, -1.30, 0.07, 0.90]. 8-bit simetrik kantizasyon uygulayalım.</p><ul><li>scale = 1.30 / 127 ≈ 0.010236</li><li>scale değerimizi bulduk 4 ağırlığın hepsini scale değerine böleriz. (41.031, -127.002, 6.838, 87.924)</li><li>Tam sayıya çevirme: [41, -127, 7, 88]</li><li>Geri dönüştürme (dequantize): [0.4197, -1.3000, 0.0717, 0.9008]</li></ul><p>Orijinale çok yakın, ama birebir aynı değil. Aradaki küçük fark <strong>kantizasyon hatasıdır</strong>. Modelde milyarlarca ağırlık olduğunda bu hataların birikimi çıktının kalitesini belirler. 4-bit’te aynı örnekte yalnızca 15 seviye (−7…7) olurdu, yani adım büyüklüğü yaklaşık 18 kat artar ve hata buna bağlı olarak büyür.</p><h3>Granülarite: Kaç ağırlık bir ölçeği paylaşır?</h3><p>Tek bir ölçeği tüm matris için kullanmak (per-tensor) basittir ama kötü sonuç verir; çünkü tek bir uç değer (outlier) tüm ölçeği bozar. Pratikte daha ince gruplar kullanılır:</p><ul><li><strong>Per-tensor:</strong> Tüm matris için tek ölçek. Hızlı, ama hatalı.</li><li><strong>Per-channel:</strong> Her çıkış kanalı için ayrı ölçek.</li><li><strong>Per-group (blok bazlı):</strong> Her 32, 64 ya da 128 ağırlık için ayrı ölçek. 4-bit yöntemlerin neredeyse tamamı bunu kullanır.</li></ul><p>Grup küçüldükçe kalite artar, ama her grup için saklanan ölçek bilgisi yüzünden bellek kazancı biraz azalır. GGUF dosyalarında bir ağırlığın “gerçek” bit maliyetinin 4 değil ~4,8 olmasının nedeni budur.</p><h3>3. Neden LLM’lerde bu kadar zor?</h3><p>Basit kantizasyon, küçük görüntü modellerinde iyi çalışır. LLM’lerde ise bir sorun var: <strong>outlier’lar</strong>. Yeterince büyük transformer modellerinde, bazı kanallarda aktivasyonlar diğerlerinden çok daha büyük değerler alır. Bu kanallar küçük bir azınlıktır, ama modelin davranışı için kritiktir. Bunları agresif biçimde kırparsanız ya da ölçeği bu uç değerlere göre ayarlarsanız, geri kalan ağırlıkların hassasiyeti çöker.</p><p>Bugün kullandığımız yöntemlerin hemen hepsi, bu problemi farklı yollardan çözmeye çalışır: bazıları outlier’ları ayrı tutar, bazıları ölçekleri kanala göre ayarlar, bazıları hata telafisi yapar.</p><h3>4. İki ana yaklaşım: PTQ ve QAT</h3><h4>Post-Training Quantization (PTQ)</h4><p>Model zaten eğitilmiştir; siz yalnızca ağırlıkları daha düşük bitlere çevirirsiniz. Yeniden eğitim gerekmez, bazen küçük bir <strong>kalibrasyon veri seti</strong> yeterlidir.</p><ul><li>✅ Hızlı, ucuz, her modele uygulanabilir</li><li>❌ 4 bit ve altında kalite düşebilir, sonuç modele göre değişir</li></ul><p>LLM dünyasında kullandığınız kantize modellerin çok büyük çoğunluğu PTQ ile üretilmiştir.</p><h4>Quantization-Aware Training (QAT)</h4><p>Model, eğitim sürecinde kantizasyonu <strong>simüle ederek</strong> öğrenir. İleri geçişte ağırlıklar kantize edilmiş gibi davranır (“fake quantization”), geri yayılım ise tam hassasiyette çalışır. Yuvarlama işleminin türevi sıfır olduğundan <strong>Straight-Through Estimator (STE)</strong> kullanılır: gradyan yuvarlamayı yok sayarak olduğu gibi geçirilir.</p><ul><li>✅ Düşük bitlerde daha yüksek kalite</li><li>❌ Eğitim maliyeti, veri ve uzmanlık gerektirir</li></ul><p>Büyük modeller için QAT pahalı olduğundan çoğu açık kaynak kullanıcı PTQ’yu tercih eder.</p><h4>Weight-only mi, weight + activation mı?</h4><p>Bir başka ayrım, <strong>neyin</strong> kantize edildiğidir:</p><ul><li><strong>Weight-only (örn. W4A16):</strong> Ağırlıklar 4 bit saklanır, hesaplama sırasında 16 bite geri açılır. Bellek ve bant genişliği kazancı büyüktür; en yaygın yaklaşımdır.</li><li><strong>Weight + activation (örn. W8A8):</strong> Hem ağırlıklar hem aktivasyonlar düşük bitle işlenir. Donanımın INT8/FP8 matris birimlerinden tam faydalanır, ama aktivasyonlardaki outlier’lar yüzünden daha zordur.</li></ul><h3>5. Önemli yöntemler</h3><h3>LLM.int8() ve bitsandbytes</h3><p>Tim Dettmers ve arkadaşlarının geliştirdiği bu yöntem, outlier problemine doğrudan çözüm getirir: outlier boyutları FP16’da bırakır, geri kalanını INT8’e çevirir (mixed-precision decomposition). Hugging Face transformers içinde tek satırla kullanılabildiği için pek çok kişinin ilk kantizasyon deneyimi budur.</p><h3>GPTQ</h3><p>Katman katman çalışan, <strong>ikinci dereceden (Hessian tabanlı) hata bilgisini</strong> kullanan bir PTQ yöntemidir. Amaç, kalibrasyon girdisi X için çıktı hatasını en aza indirmektir:</p><pre>min || W·X − Ŵ·X ||²</pre><p>Yani amaç ağırlıkları tek tek orijinaline yaklaştırmak değil, <strong>katmanın çıktısını</strong> korumaktır. Bir ağırlık yuvarlanırken oluşan hata, henüz kantize edilmemiş ağırlıklara dağıtılarak telafi edilir. Sonuç olarak 4-bit’te çok iyi kalite elde edilir. GPU çıkarımı için tasarlanmıştır.</p><h3>AWQ (Activation-aware Weight Quantization)</h3><p>AWQ’nun temel fikri şudur: <strong>Tüm ağırlıklar eşit derecede önemli değildir.</strong> Bir ağırlığın önemi, ondan geçen aktivasyonların büyüklüğüyle ilişkilidir. AWQ, kritik kanalları aktivasyon istatistiklerine bakarak belirler ve bu kanallara kanal bazlı ölçekleme uygulayarak onları korur. Geri kalanlar daha agresif sıkıştırılır. Pratikte GPTQ ile benzer seviyede, çoğu zaman çok yakın kalite sunar ve kalibrasyon verisine daha az hassastır.</p><h3>SmoothQuant</h3><p>W8A8 yaklaşımında aktivasyon outlier’larını çözmek için geliştirildi. Kantizasyonun zorluğunu matematiksel bir ölçekleme ile aktivasyonlardan ağırlıklara <strong>kaydırır</strong>; böylece her ikisi de INT8’e daha uygun hale gelir.</p><h3>NF4 ve QLoRA</h3><p>NF4 (4-bit NormalFloat), sinir ağı ağırlıklarının yaklaşık normal dağılım izlemesinden faydalanan, 4-bit’lik özel bir veri tipidir. Seviyeler eşit aralıklı değil, normal dağılıma uygun yerleştirilir. QLoRA ile birlikte popülerleşti: modeli 4-bit olarak dondurup üzerine küçük LoRA adaptörleri eğiterek büyük modelleri tek GPU’da <strong>ince ayar</strong> (fine-tuning) yapmayı mümkün kıldı.</p><h3>GGUF ve llama.cpp</h3><p>GGUF, llama.cpp ekosisteminin dosya formatıdır. Blok bazlı kantizasyon kullanır ve <strong>CPU’da bile verimli çalışması</strong> en büyük artısıdır. Ayrıca CPU ile GPU arasında katman paylaşımı (offloading) yapabilir; yani modelin bir kısmı GPU’da, kalanı RAM’de çalışabilir. İsimlendirme ilk bakışta karışık görünür, ama mantığı basittir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/661/1*L2f9Ym-chWFpdnDhE3hxtA.png" /></figure><p>Değerler modele göre küçük farklar gösterir. Pratikte <strong>Q4_K_M</strong> ve <strong>Q5_K_M</strong>, boyut ile kalite arasındaki en popüler denge noktalarıdır. Adlandırmadaki “K”, k-quant ailesini; “M” ise orta (medium) karma hassasiyet profilini ifade eder.</p><h3>FP8</h3><p>Yeni nesil GPU’lar (örneğin NVIDIA H100 sınıfı) FP8 formatını donanımda destekler. INT8’e kıyasla daha geniş dinamik aralık sunduğu için hem eğitimde hem çıkarımda giderek yaygınlaşıyor.</p><h3>6. Kalite ne kadar düşüyor?</h3><p>Kantizasyonun kalite etkisi genelde <strong>perplexity</strong> ile ölçülür: modelin bir metin kümesindeki “şaşkınlık” değeri. Düşük olması iyidir; kantizasyon sonrası artış ne kadar küçükse o kadar iyi. Ama perplexity tek başına yeterli değildir; gerçek görevlerde (kod yazma, matematik, uzun muhakeme, çok dilli kullanım) fark daha belirgin olabilir.</p><p>Genel gözlemler şöyle özetlenebilir:</p><ul><li><strong>8-bit</strong> çoğu durumda pratikte fark edilmez.</li><li><strong>4-bit</strong> (iyi bir yöntemle, grup bazlı) birçok uygulama için kabul edilebilir bir denge noktasıdır.</li><li><strong>3-bit ve altı</strong> belirgin kalite kaybı getirir; ancak özel yöntemlerle bu alan hızla ilerliyor.</li><li><strong>Büyük modeller kantizasyona daha dayanıklıdır.</strong> 4-bit’lik 70B’lik bir model, çoğu zaman FP16’lık 7B’lik bir modelden daha iyidir; ama 4-bit’lik 1–3B’lik küçük modellerde kayıp daha hissedilir.</li><li><strong>Kod, matematik ve çok adımlı muhakeme</strong> gibi hassas görevlerde kayıp, genel sohbete göre daha erken ortaya çıkabilir.</li></ul><p><strong>Önemli not:</strong> Türkçe gibi eğitim verisinde görece az temsil edilen dillerde kantizasyonun etkisini mutlaka <strong>kendi test setinizle</strong> ölçün. İngilizce benchmark sonuçları, sizin kullanım senaryonuz için güvenilir bir vekil olmayabilir.</p><h3>Kantizasyonun ötesi: KV cache</h3><p>Model ağırlıklarını küçülttükten sonra bellekte başka bir kalem öne çıkar: <strong>KV cache</strong>.</p><p>Transformer modeller metin üretirken, her yeni token için önceki tüm token’ların Key ve Value matrislerine ihtiyaç duyar. KV cache bunları yeniden hesaplamak yerine saklar. Hız kazandırır, ama bağlam uzunluğu arttıkça bellek tüketimi doğrusal olarak büyür:</p><pre>KV cache boyutu = 2 × katman × KV kafa sayısı × kafa boyutu × token sayısı × bayt</pre><p>Örnek: 32 katmanlı, 32 KV kafalı, kafa boyutu 128 olan bir model (Llama 2 7B yapısı), 4096 token bağlamda ve FP16’da <strong>tek bir istek</strong> için yaklaşık <strong>2 GB</strong> KV cache kullanır. Aynı anda 16 kullanıcıya hizmet verirseniz bu 32 GB eder; yani ağırlıkları 4-bit yapmış olsanız bile bellek hâlâ sıkışabilir.</p><p>Bu yüzden kantizasyon ile birlikte şu teknikler sık kullanılır:</p><ul><li><strong>KV cache kantizasyonu:</strong> Cache’i FP16 yerine INT8 veya FP8 gibi formatlarda saklamak.</li><li><strong>GQA / MQA:</strong> Birden fazla query kafasının aynı Key/Value kafasını paylaşması. Cache’i doğrudan küçültür. Modern modellerin birçoğu GQA kullanır.</li><li><strong>PagedAttention (vLLM):</strong> KV cache’i işletim sistemi sayfalama mantığıyla yönetir ve bellek parçalanmasını azaltır.</li><li><strong>Flash Attention:</strong> Attention hesabını GPU’nun hızlı SRAM’inde, blok blok yaparak devasa N×N matrisin yavaş belleğe yazılmasını önler. Matematiksel sonuç aynıdır; yalnızca daha hızlı ve daha az bellekle hesaplanır.</li><li><strong>Continuous batching:</strong> Biten isteğin yerine hemen yenisini koyarak GPU’yu boş bırakmaz.</li></ul><p>Kısacası kantizasyon tek başına sihirli değnek değil; üretim ortamında en iyi sonuç bu tekniklerin birlikte kullanımıyla gelir.</p><h3>Hangi yöntemi seçmeliyim?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*FULV5c8F7p0utHC3NAerNQ.png" /></figure><p>Kısa bir kural olarak: <strong>önce daha büyük bir modeli daha düşük bitle</strong> denemek, çoğu zaman <strong>daha küçük bir modeli yüksek bitle</strong> çalıştırmaktan iyi sonuç verir. Ama bunu her zaman kendi görevinizde doğrulayın.</p><h3>Sık yapılan hatalar</h3><ol><li><strong>Sadece perplexity’ye bakmak.</strong> Gerçek görevlerinizle (örneğin Türkçe soru-cevap, kod, özetleme) ayrıca test edin.</li><li><strong>Kalibrasyon verisini göz ardı etmek.</strong> GPTQ ve AWQ’da kalibrasyon setinin dil ve alan olarak hedef kullanıma benzemesi önemlidir.</li><li><strong>Yalnızca ağırlık boyutuna bakmak.</strong> KV cache ve aktivasyonlar da belleğe girer; uzun bağlamda asıl darboğaz çoğu zaman cache olur.</li><li><strong>Çok düşük bite inmek.</strong> 2–3 bit etkileyici görünür, ama özellikle küçük modellerde muhakeme ve talimat takibi belirgin zarar görebilir.</li><li><strong>Her donanımda aynı hızı beklemek.</strong> Kantizasyonun hız kazancı, kullanılan kernel’e ve donanımın desteğine bağlıdır. Bellek kazancı garantidir, hız kazancı değil.</li><li><strong>Kantize modeli tekrar kantize etmek.</strong> Hatalar birikir; her zaman orijinal (FP16/BF16) modelden başlayın.</li></ol><h3>Sonuç</h3><p>Kantizasyon, LLM’leri veri merkezlerinden çıkarıp günlük donanıma taşıyan en önemli tekniklerden biri. Temel fikir basit: sayıları daha az bitle sakla, ama kayıp en az olsun. Zorluk ise “kayıp en az olsun” kısmında yatıyor; GPTQ’nun hata telafisi, AWQ’nun kritik kanalları koruması, GGUF’un blok bazlı yapısı ve NF4’ün dağılıma uygun seviyeleri hep bu soruya verilmiş farklı yanıtlar.</p><p>Pratik özet:</p><ul><li>8-bit güvenli bir başlangıçtır.</li><li>4-bit çoğu uygulama için ideal denge noktasıdır.</li><li>Yöntemi donanımınıza ve kullanım senaryonuza göre seçin.</li><li>Kantizasyonu KV cache, Flash Attention ve batching gibi tekniklerle birlikte düşünün.</li><li>Son sözü her zaman <strong>kendi veriniz üzerindeki testler</strong> söylesin.</li></ul><p>Bir sonraki adım olarak, ilgilendiğiniz bir modeli seçip FP16, Q8_0 ve Q4_K_M versiyonlarını kendi sorularınızla yan yana karşılaştırmanızı öneririm. Farkı kendi gözünüzle görmek, bu yazıdaki tüm rakamlardan daha öğretici olacaktır.</p><p><em>Okuduğunuz için teşekkürler. Yazıyı beğendiyseniz alkışlamayı ve sorularınızı yorumlarda paylaşmayı unutmayın.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1e20a13bfb0a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[RAG Nedir? Sıfırdan Başlayanlar İçin Retrieval-Augmented Generation Rehberi]]></title>
            <link>https://medium.com/@eren.alltun/rag-nedir-s%C4%B1f%C4%B1rdan-ba%C5%9Flayanlar-i%CC%87%C3%A7in-retrieval-augmented-generation-rehberi-b93c937be3ce?source=rss-a95e2cc08f44------2</link>
            <guid isPermaLink="false">https://medium.com/p/b93c937be3ce</guid>
            <dc:creator><![CDATA[Eren ALTUN]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 05:50:55 GMT</pubDate>
            <atom:updated>2026-11-09T05:50:55.419Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Yapay zekâ modellerine “ezberinden cevap ver” yerine “önce belgelere bak, sonra cevap ver” demenin yolu. Teori, örnekler ve çalışan Python kodu ile.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L9khF6OUR9_TXeGeSd8CVw.jpeg" /></figure><h3>Giriş: Neden bu yazıyı okumalısın?</h3><p>ChatGPT, Claude veya Gemini gibi araçlarla sohbet ettiysen, bu modellerin neredeyse her konuda konuşabildiğini görmüşsündür. Ama bir şirketin iç yönetmeliğini, dün yayımlanan bir haberi ya da kendi ders notlarını sorduğunda ya “bilmiyorum” derler ya da daha kötüsü, kulağa çok makul gelen yanlış bir cevap uydururlar.</p><p><strong>RAG (Retrieval-Augmented Generation)</strong>, tam olarak bu sorunu çözmek için geliştirilmiş bir yöntemdir. Türkçesi “Getirme ile Güçlendirilmiş Üretim”dir.</p><p>Bu yazıda RAG’ı hiç bilmeyen birinin bile sonuna geldiğinde şunları yapabilmesini hedefliyorum:</p><ul><li>RAG’ın ne olduğunu ve neden gerektiğini kendi cümleleriyle anlatmak</li><li>Bir RAG sisteminin her adımını (parçalama, embedding, arama, prompt, üretim) açıklamak</li><li>Sıfırdan çalışan basit bir RAG sistemi yazmak</li><li>RAG ile fine-tuning arasındaki farkı söylemek</li><li>Sık yapılan hataları ve çözüm yollarını bilmek</li></ul><h3>1. Önce sorun: Büyük dil modellerinin üç sınırı</h3><p>Büyük dil modelleri (LLM) devasa miktarda metinle eğitilir. Eğitim bittiğinde model, gördüğü bilgileri bir tür “sıkıştırılmış hafıza” olarak taşır. Bu hafızanın üç önemli zayıflığı vardır:</p><h4>1.1 Bilgi eskir</h4><p>Model, eğitim verisinin bittiği tarihten sonra olanları bilmez. Dünkü bir gelişmeyi sorarsan elinde veri yoktur.</p><h4>1.2 Özel veriyi bilmez</h4><p>Şirket içi belgeler, üniversite yönetmelikleri, kişisel notların ya da müşteri kayıtların modelin eğitim verisinde yoktur. Model bunları görmediği için cevaplayamaz.</p><h4>1.3 Halüsinasyon</h4><p>Model, bilmediği bir soruyla karşılaştığında “bilmiyorum” demek yerine akıcı ve inandırıcı ama yanlış bir cevap üretebilir. Buna <strong>halüsinasyon</strong> denir. Çünkü dil modeli özünde “bir sonraki kelimeyi tahmin eden” bir sistemdir; doğruluğu kontrol eden bir mekanizması yoktur.</p><blockquote><strong><em>Kısaca:</em></strong><em> LLM’ler ezberden konuşur. Ezber eskiyebilir, eksik olabilir ya da yanlış hatırlanabilir.</em></blockquote><h3>2. RAG nedir? Açık kitap sınavı benzetmesi</h3><p>İki tür sınav düşün:</p><ul><li><strong>Kapalı kitap sınavı:</strong> Sadece kafandakilerle cevap verirsin. Unuttuysan tahmin yürütürsün.</li><li><strong>Açık kitap sınavı:</strong> Soruyu okur, ilgili sayfayı bulur, oradan bakarak cevap yazarsın.</li></ul><p>Sadece LLM kullanmak kapalı kitap sınavına benzer. <strong>RAG ise modeli açık kitap sınavına sokmaktır.</strong></p><p><strong>Tek cümlelik tanım:</strong> RAG, bir dil modeli cevap üretmeden önce harici bir bilgi kaynağından (belgeler, veritabanı, notlar) soruyla ilgili parçaları bulup bunları modele bağlam olarak vermesi yöntemidir.</p><p>Adındaki üç kelime de bu işi anlatır:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*WOH9e_9Ib_WZ4W7GL0nt9w.png" /></figure><p>Önemli nokta şu: <strong>Model yeniden eğitilmez.</strong> Bilgi, her soru geldiği anda prompt’a eklenir.</p><h3>3. RAG’ın büyük resmi</h3><p>Bir RAG sistemi iki ayrı aşamadan oluşur:</p><p><strong>A) İndeksleme (bir kez yapılır, hazırlık aşaması)</strong></p><p>Belgeler → Parçalama (chunking) → Embedding (metni vektöre çevirme) → Vektör veritabanı</p><p><strong>B) Sorgulama (her soruda yapılır)</strong></p><p>Kullanıcı sorusu → Embedding → Retrieval (en benzer parçaları bul) → Prompt oluştur → LLM → Kaynaklı cevap</p><p>İndeksleme, kütüphaneye kitapları düzenli bir şekilde dizmeye benzer. Sorgulama ise biri bir soru sorduğunda doğru rafa gidip ilgili sayfaları çıkarmaktır.</p><p>Şimdi her adımı tek tek, hem mantığıyla hem koduyla inceleyelim.</p><h3>4. Adım adım RAG</h3><h4>Adım 1: Belgeleri topla</h4><p>Modelin bilmesini istediğin her şey buraya girer: PDF’ler, Word dosyaları, web sayfaları, veritabanı kayıtları, ders notları.</p><p>Basit bir örnek için birkaç cümlelik belgelerle başlayalım:</p><pre>documents = [<br>    &quot;Python, Guido van Rossum tarafından geliştirilen ve ilk sürümü 1991&#39;de yayımlanan yüksek seviyeli bir programlama dilidir.&quot;,<br>    &quot;RAG (Retrieval-Augmented Generation), büyük dil modellerinin cevap üretmeden önce harici bir bilgi kaynağından ilgili belgeleri getirmesi yöntemidir.&quot;,<br>    &quot;Vektör veritabanları, metinlerin sayısal temsillerini (embedding) saklar ve benzerlik araması yapar. FAISS, Chroma, Qdrant ve Pinecone yaygın örneklerdir.&quot;,<br>    &quot;İstanbul, Türkiye&#39;nin en kalabalık şehridir. Ayasofya ve Topkapı Sarayı şehrin önemli tarihi yapılarıdır.&quot;,<br>    &quot;Kosinüs benzerliği, iki vektör arasındaki açının kosinüsünü ölçer. Değer 1&#39;e yaklaştıkça vektörler birbirine daha benzerdir.&quot;,<br>]</pre><p>Gerçek projelerde bu liste bir klasördeki dosyalardan okunur.</p><h4>Adım 2: Parçalara böl (Chunking)</h4><p>Uzun bir belgeyi olduğu gibi modele veremeyiz. Hem modelin bağlam penceresi (aynı anda okuyabileceği metin miktarı) sınırlıdır hem de 100 sayfalık bir belgenin içinden sadece iki paragraf lazımdır. Bu yüzden belgeler <strong>küçük parçalara (chunk)</strong> bölünür. Pratikte parça boyutu genelde 200–500 kelime civarıdır.</p><p>Bölme sırasında bir ince nokta vardır: Bir cümle tam iki parçanın sınırında kalırsa anlam kopabilir. Bunu önlemek için parçalar arasında <strong>örtüşme (overlap)</strong> bırakılır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DvS50_CpgNKWHlBrh6XLrg.jpeg" /></figure><pre>def chunk_text(text, chunk_size=80, overlap=20):<br>    words = text.split()<br>    step = max(1, chunk_size - overlap)<br>    chunks = []<br>    for i in range(0, len(words), step):<br>        chunks.append(&quot; &quot;.join(words[i:i + chunk_size]))<br>        if i + chunk_size &gt;= len(words):<br>            break<br>    return chunks</pre><p>Bu fonksiyon metni kelimelere ayırır ve chunk_size kelimelik pencereleri step kadar kaydırarak parçalar üretir. overlap kadar kelime, ardışık iki parçada ortak kalır.</p><p><strong>Parça boyutu neden önemli?</strong></p><ul><li><strong>Çok büyük parça:</strong> İçine alakasız bilgi de girer, model dağılır.</li><li><strong>Çok küçük parça:</strong> Bağlam kopar, tek başına anlam taşımaz.</li></ul><p>Doğru boyut, verinin türüne göre denenerek bulunur.</p><h4>Adım 3: Metni vektöre çevir (Embedding)</h4><p>Bilgisayar kelimelerin anlamını doğrudan anlayamaz. Bu yüzden her metin parçası, anlamını temsil eden bir <strong>sayı dizisine (vektöre)</strong> dönüştürülür. Bu işe <strong>embedding</strong> denir ve bunu yapan özel modellere <strong>embedding modeli</strong> denir.</p><p>Embedding’in sihri şudur: <strong>Anlamca yakın metinlerin vektörleri de birbirine yakın çıkar.</strong></p><pre>&quot;köpek havlıyor&quot;     → [0.21, -0.43, 0.88, ...]<br>&quot;it ses çıkarıyor&quot;   → [0.19, -0.40, 0.85, ...]   ← yakın<br>&quot;borsa yükseldi&quot;     → [-0.71, 0.32, 0.05, ...]   ← uzak</pre><p>İlk iki cümlede ortak kelime yok (“köpek” ve “it” farklı kelimeler) ama anlamları benzer olduğu için vektörleri de benzerdir. Klasik anahtar kelime aramasından farkı budur: <strong>anlam bazlı arama yapabilmek.</strong></p><p>Kodda çok dilli (Türkçe destekli) küçük bir model kullanıyoruz:</p><pre>import numpy as np<br>from sentence_transformers import SentenceTransformer<br><br>embedder = SentenceTransformer(&quot;sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2&quot;)<br><br>chunk_vectors = embedder.encode(chunks, normalize_embeddings=True)<br>chunk_vectors = np.asarray(chunk_vectors, dtype=&quot;float32&quot;)</pre><p>normalize_embeddings=True ayarı vektörlerin uzunluğunu 1&#39;e eşitler. Bunun neden işe yaradığını bir sonraki adımda göreceğiz.</p><h4>Adım 4: Vektör veritabanına kaydet</h4><p>Vektörler, benzerlik araması için özelleştirilmiş bir <strong>vektör veritabanında</strong> saklanır. Yaygın örnekler <strong>FAISS, Chroma, Qdrant ve Pinecone</strong>’dur.</p><p>Bizim örneğimizde işi basit tutmak için veritabanı yerine sadece bir <strong>NumPy matrisi</strong> kullanıyoruz (chunk_vectors). Küçük veri için yeterlidir; milyonlarca parça olduğunda gerçek bir vektör veritabanına geçilir.</p><h4>Adım 5: Soruya en benzer parçaları getir (Retrieval)</h4><p>Kullanıcı bir soru sorduğunda:</p><ol><li>Soru, <strong>aynı embedding modeliyle</strong> vektöre çevrilir.</li><li>Bu vektör, veritabanındaki tüm parça vektörleriyle karşılaştırılır.</li><li>En benzer <strong>k</strong> parça (genelde 3–5 tane) seçilir.</li></ol><p>Benzerlik çoğunlukla <strong>kosinüs benzerliği</strong> ile ölçülür. Bu ölçü iki vektör arasındaki açının kosinüsüne bakar:</p><ul><li>Değer <strong>1&#39;e yakınsa</strong> vektörler çok benzerdir (aynı yöne bakıyorlar).</li><li>Değer <strong>0&#39;a yakınsa</strong> ilgisizdirler.</li></ul><p>Vektörleri normalize ettiğimiz için kosinüs benzerliği, basit bir <strong>iç çarpıma</strong> (dot product) dönüşür. Kodda @ operatörü bunu yapar:</p><pre>def retrieve(query, k=3):<br>    q = embedder.encode([query], normalize_embeddings=True)[0]<br>    scores = chunk_vectors @ q                 # kosinüs benzerliği<br>    top = np.argsort(-scores)[:k]              # en yüksek k skor<br>    return [{&quot;chunk&quot;: chunks[i], &quot;score&quot;: float(scores[i]), &quot;doc_id&quot;: sources[i]} for i in top]</pre><p>np.argsort(-scores) skorları büyükten küçüğe sıralar, [:k] ise ilk k tanesini alır.</p><p>Örneğin retrieve(&quot;RAG nedir?&quot;) çağrısı, RAG&#39;ı tanımlayan belgeyi en yüksek skorla getirecektir.</p><h4>Adım 6: Prompt oluştur (Augmentation)</h4><p>Bulunan parçalar, kullanıcının sorusuyla birlikte tek bir talimata yerleştirilir. RAG’daki “Augmented” (güçlendirme) tam olarak bu adımdır:</p><pre>def build_prompt(query, hits):<br>    context = &quot;\n\n&quot;.join(f&quot;[{i+1}] {h[&#39;chunk&#39;]}&quot; for i, h in enumerate(hits))<br>    return f&quot;&quot;&quot;Aşağıdaki bağlamı kullanarak soruyu Türkçe cevapla.<br>Cevap bağlamda yoksa &quot;Bağlamda bu bilgi yok.&quot; de. Kullandığın kaynakları [1], [2] gibi belirt.<br><br>### Bağlam<br>{context}<br><br>### Soru<br>{query}<br><br>### Cevap&quot;&quot;&quot;</pre><p>Bu prompt’taki iki talimat çok kritiktir:</p><ul><li><strong>“Cevap bağlamda yoksa ‘Bağlamda bu bilgi yok.’ de.”</strong> → Halüsinasyonu azaltır. Model uydurmak yerine dürüstçe bilmediğini söyler.</li><li><strong>“Kaynakları [1], [2] gibi belirt.”</strong> → Cevap doğrulanabilir hale gelir.</li></ul><h4>Adım 7: LLM cevap üretsin (Generation)</h4><p>Son adımda prompt, bir dil modeline gönderilir. Model artık ezberine değil, önüne konan bağlama dayanarak cevap verir.</p><pre>import os<br><br>def generate(prompt, model=&quot;claude-sonnet-5-5&quot;, max_tokens=800):<br>    if not os.environ.get(&quot;ANTHROPIC_API_KEY&quot;):<br>        return &quot;(API anahtarı yok — LLM&#39;e gönderilecek prompt:)\n\n&quot; + prompt<br>    import anthropic<br>    client = anthropic.Anthropic()<br>    msg = client.messages.create(<br>        model=model,<br>        max_tokens=max_tokens,<br>        messages=[{&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: prompt}],<br>    )<br>    return &quot;&quot;.join(block.text for block in msg.content if block.type == &quot;text&quot;)</pre><p>Bu fonksiyon yalnızca bir örnektir. OpenAI, Ollama ya da başka bir LLM kullanmak istersen sadece generate fonksiyonunu değiştirmen yeterlidir. RAG&#39;ın diğer parçaları modelden bağımsızdır.</p><h3>Hepsini birleştirelim</h3><pre>def rag(query, k=3, verbose=True):<br>    hits = retrieve(query, k)<br>    if verbose:<br>        print(&quot;Getirilen parçalar:&quot;)<br>        for i, h in enumerate(hits, 1):<br>            print(f&quot;  [{i}] ({h[&#39;score&#39;]:.3f}) {h[&#39;chunk&#39;][:70]}...&quot;)<br>        print()<br>    return generate(build_prompt(query, hits))<br><br>print(rag(&quot;RAG nedir ve neden kullanılır?&quot;))<br>print(rag(&quot;İstanbul&#39;daki tarihi yapılar nelerdir?&quot;))<br>print(rag(&quot;Ay&#39;a ilk kim ayak bastı?&quot;))   # bağlamda yok!</pre><p>Üç sorunun üçü de farklı bir durumu gösterir:</p><ol><li><strong>RAG sorusu:</strong> İlgili belge bulunur, model bağlama dayanarak cevaplar.</li><li><strong>İstanbul sorusu:</strong> İstanbul belgesi bulunur, Ayasofya ve Topkapı Sarayı cevapta yer alır.</li><li><strong>Ay sorusu:</strong> Belgelerimizde bu bilgi yoktur. Prompt’taki talimat sayesinde model uydurmak yerine “Bağlamda bu bilgi yok.” der. Sistemin dürüstlüğünü test etmenin en iyi yolu budur.</li></ol><h4>5. Somut bir senaryo: Üniversite yönetmeliği asistanı</h4><p>Teoriyi pekiştirmek için gerçek hayattan bir örnek düşünelim. Bir üniversitenin öğrenci yönetmeliği üzerine soru-cevap asistanı yapıyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/581/1*4o7fZtF4dtssYePIJsw2TQ.png" /></figure><p>RAG olmasaydı model, genel üniversite kurallarından tahmin yürütürdü ve o kuruma özel kuralı bilemezdi. RAG sayesinde cevap, kurumun gerçek belgesine dayanır ve kaynak gösterilebilir.</p><h3>6. RAG mı, Fine-tuning mi?</h3><p>Bu, en sık karıştırılan konulardan biridir. <strong>Fine-tuning (ince ayar)</strong>, modelin ağırlıklarını ek verilerle yeniden eğitmektir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*9ozzQbbcRMjqGmClReb5wQ.png" /></figure><p>Basit bir hafıza kuralı: <strong>Bilgi eklemek istiyorsan RAG, davranışı değiştirmek istiyorsan fine-tuning.</strong> İkisi rakip değildir, birlikte de kullanılabilir.</p><p>Bir de <strong>sadece LLM</strong> kullanmayla kıyaslayalım:</p><ul><li><strong>Sadece LLM:</strong> Eğitim verisiyle sınırlı, özel veriyi bilmez, kaynak gösteremez, uydurma riski yüksek.</li><li><strong>LLM + RAG:</strong> Güncel ve özel bilgiye erişir, belgeler değişince sadece indeks güncellenir, kaynak gösterebilir, uydurma riski azalır.</li></ul><h3>7. Sık karşılaşılan sorunlar ve çözümleri</h3><p>RAG basit görünür ama pratikte dikkat edilmesi gereken noktalar vardır:</p><p><strong>1. Yanlış parça geliyor.</strong> Soru ile belge farklı kelimeler kullanıyorsa arama ilgili parçayı kaçırabilir. <em>Çözüm:</em> Daha iyi bir embedding modeli, hibrit arama, reranking.</p><p><strong>2. Cevap iki parçaya bölünmüş.</strong> Gerekli bilgi iki ayrı parçada kalmış olabilir. <em>Çözüm:</em> Overlap kullanmak, daha akıllı chunking, k değerini artırmak.</p><p><strong>3. Model bağlamı yok sayıyor.</strong> Model yine ezberinden cevap verebilir. <em>Çözüm:</em> Prompt’ta “sadece bağlamı kullan” talimatı, kaynak göstermeyi zorunlu kılmak.</p><p><strong>4. Tablo ve görseller bozuluyor.</strong> PDF’teki tablolar düz metne çevrilince anlamını yitirebilir. <em>Çözüm:</em> Belge türüne özel ayrıştırıcılar kullanmak.</p><h3>8. Temel RAG’ı nasıl geliştiririz?</h3><p>Yukarıda kurduğumuz sistem “temel” RAG’dır. Üretim ortamında şu teknikler sıkça eklenir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/697/1*HCclyNJ8kSqEly0_4gPLcw.png" /></figure><h4>Sistemi nasıl değerlendiririz?</h4><p>RAG’ın iki ayrı parçası vardır ve ikisi ayrı ölçülür:</p><ul><li><strong>Recall (geri çağırma):</strong> Doğru parça gerçekten getirildi mi? Bu, retrieval’ın kalitesini ölçer.</li><li><strong>Faithfulness (sadakat):</strong> Cevap getirilen bağlama sadık mı, yoksa model araya uydurma mı kattı? Bu, generation’ın kalitesini ölçer.</li></ul><p>Bir RAG sistemi kötü cevap veriyorsa önce şunu sor: <em>Sorun getirmede mi, üretimde mi?</em> Doğru parça hiç gelmemişse retrieval’ı, geldiği halde model yanlış cevaplamışsa prompt’u ya da modeli düzeltmen gerekir.</p><h3>9. Gelişmiş RAG</h3><p>Temel RAG küçük bir bilgi tabanında iyi çalışır, ama gerçek belgelerde üç yerde tökezler: soru ile belge farklı kelimeler kullanır, sistem ürün kodu veya rakamı kaçırır, ya da gelen parçalar alakasız veya birbirinin tekrarı olur. Gelişmiş RAG, aynı iskeletin her adımına bir iyileştirme ekleyerek bu sorunları çözer.</p><p>Bu bölümdeki örnekler kurgusal bir şirketin (<em>Örnek Teknoloji A.Ş.</em>) çalışan el kitabı üzerinde çalışır: izin, uzaktan çalışma, masraf, bilgi güvenliği ve eğitim politikaları. Bilgi güvenliği politikasının hem 2022 (eski) hem 2025 (yeni) sürümü bilerek birlikte konmuştur; böylece metadata filtresinin neden gerekli olduğu görülür.</p><h3>9.1 Gelişmiş akış: 7 adım</h3><p>Soru geldiğinde sistem sırayla şunları yapar:</p><ol><li><strong>Condense:</strong> Takip sorusunu sohbet geçmişine bakarak tek başına anlaşılır hale getirir.</li><li><strong>Sorgu varyantları:</strong> Soruyu farklı kelimelerle yeniden yazar (multi-query, HyDE).</li><li><strong>Hibrit arama:</strong> Her varyant için hem dense (embedding) hem sparse (BM25) arama yapar.</li><li><strong>RRF:</strong> Tüm arama sonuçlarını tek bir sıralamada birleştirir.</li><li><strong>Reranking:</strong> İlk adayları cross-encoder ile yeniden puanlar.</li><li><strong>MMR:</strong> Birbirinin tekrarı olan parçaları eler, çeşitli olanları seçer.</li><li><strong>Komşu genişletme:</strong> Seçilen parçanın yanındaki parçaları da ekler, sonra prompt’u kurar.</li></ol><h3>9.2 Dense ve sparse arama</h3><p>İki arama türü birbirini tamamlar: <strong>dense</strong> anlamı, <strong>sparse</strong> tam kelimeyi yakalar.</p><p><strong>Dense (yoğun) arama</strong>, 4. bölümde gördüğümüz embedding aramasıdır. Metin, yüzlerce sayıdan oluşan bir vektöre çevrilir; bu vektörün neredeyse her sayısı doludur, bu yüzden “yoğun” denir. “Köpek havlıyor” ile “it ses çıkarıyor” ortak kelime taşımasa da yakın çıkar.</p><p><strong>Sparse (seyrek) arama</strong>, kelime eşleşmesine dayanır. Metin, sözlükteki her kelime için bir boyut taşıyan çok uzun bir vektör gibi düşünülebilir; ama bir parçada sadece birkaç kelime geçtiği için neredeyse tüm değerler sıfırdır, bu yüzden “seyrek” denir. En yaygın sparse yöntem <strong>BM25</strong>&#39;tir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/1*XL1v6qHKHBa1_VBB8sSi4w.png" /></figure><h4>BM25 nasıl çalışır?</h4><p>BM25, bir parçanın soruyla ne kadar ilgili olduğunu üç fikirle puanlar:</p><ul><li><strong>Terim sıklığı (TF):</strong> Soru kelimesi parçada ne kadar çok geçiyorsa puan artar, ama artış giderek azalır.</li><li><strong>Ters belge sıklığı (IDF):</strong> Az parçada geçen kelime değerlidir. “İzin” nadirse çok puan verir; “ve” gibi her yerde geçen kelime neredeyse puan vermez.</li><li><strong>Uzunluk normalizasyonu:</strong> Uzun parçalar sırf uzun oldukları için kayırılmaz.</li></ul><p>BM25 kodda ters indeksle çalışır: her kelime için “hangi parçada kaç kez geçti” listesi tutulur, soru kelimeleri sadece bu listelere bakar.</p><h4>Türkçe için ince ayar</h4><p>Türkçe sondan eklemeli bir dildir: <em>izin, izinler, izinlerin, izni</em> aynı kökten gelir ama BM25 bunları farklı kelime sayar. Çözüm olarak notebook’taki yöntem her kelimeyi <strong>ilk 5 harfe kırpar</strong> (F5 stemming). Böylece izinler ve izinlerin aynı köke (izinl) iner. Yöntem kusursuz değildir (izin ve izni ayrı köklerde kalır) ama ek alan kelimelerin çoğunu pratikte yakalar. Ayrıca iki küçük ayrıntı ele alınır:</p><ul><li><strong>Büyük/küçük harf:</strong> Türkçede I harfinin küçüğü ı, İ harfinin küçüğü i&#39;dir. Standart lower() bunu yanlış yapar, o yüzden özel bir fonksiyon yazılır.</li><li><strong>Etkisiz kelimeler (stopwords):</strong> “ve, bir, için, ile, çok” gibi kelimeler listeden atılır.</li></ul><pre>def tr_lower(s):<br>    return s.replace(&quot;I&quot;, &quot;ı&quot;).replace(&quot;İ&quot;, &quot;i&quot;).lower()<br><br>def tokenize(text, stem=5):<br>    toks = re.findall(r&quot;[0-9a-zçğıöşüâîû]+&quot;, tr_lower(text))<br>    return [t[:stem] if (stem and not t.isdigit()) else t<br>            for t in toks if t not in TR_STOP and len(t) &gt; 1]</pre><p>Rakamlar kırpılmaz, çünkü “5.000” gibi değerlerin tam eşleşmesi önemlidir.</p><p>Rakamlar kırpılmaz, çünkü “5.000” gibi değerlerin tam eşleşmesi önemlidir.</p><h3>9.3 Hibrit arama ve RRF</h3><p><strong>Hibrit arama</strong>, dense ve sparse aramayı birlikte çalıştırıp sonuçlarını birleştirmektir. Böylece hem “anlamca yakın” hem “kelimesi tam geçen” parçalar yakalanır. Asıl soru şudur: iki farklı arama iki farklı puan ölçeği üretir (kosinüs 0–1 arası, BM25 ise 0–20 gibi). Bu puanları nasıl toplarız?</p><h4>Reciprocal Rank Fusion (RRF)</h4><p>RRF’nin cevabı basittir: <strong>puanları değil, sıraları birleştir.</strong> Her arama yönteminde bir parçanın kaçıncı sırada olduğuna bakılır ve sıra ne kadar iyiyse o kadar katkı verilir. Puan ölçeklerinin birbirine uyup uymadığı önemsiz hale gelir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/312/1*V02m5U9yuDrDxzeybMx25A.png" /></figure><p>Burada d bir parça, R arama listelerinin kümesi, sıra parçanın o listedeki sırası (1&#39;den başlar), w listenin ağırlığı, k ise sabittir (genelde <strong>60</strong>). k büyüdükçe ilk sıralarla sonraki sıralar arasındaki fark azalır.</p><p><strong>Sayısal örnek</strong> (k = 60, ağırlıklar eşit):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/492/1*mhBVRNQTFLrMUkuOrId13Q.png" /></figure><p>Sonuç sıralaması <strong>B, A, D, C</strong> olur. Dense’te ikinci olan B, sparse’ta birinci olduğu için A’yı geçer. İki listede birden üst sıralarda yer alan parça kazanır, tek listede görünen parça geride kalır.</p><p><strong>RRF neden popüler?</strong></p><ul><li>Puan ölçeklerini normalize etme derdi yoktur.</li><li>Tek bir yöntemin aşırı yüksek puanı sonucu domine etmez.</li><li>İstenirse dense_weight ve sparse_weight ile bir tarafa daha çok ağırlık verilebilir (örneğin kod ve rakam aramaları çoksa sparse artırılır).</li></ul><h4>Üç fikri birlikte anlayalım: sıra, kök, anlam</h4><p>Hibrit aramayı anlamak için üç cümleyi aklında tut:</p><ol><li><strong>Sparse köke bakar.</strong> BM25, sorudaki kelimeler parçada geçiyor mu diye bakar. Türkçede kelime ekli olduğu için kelimeler köke (ilk 5 harfe) indirilir. Soruda “izinlerin”, belgede “izinler” yazsa bile ikisi izinl köküne dönüşüp eşleşir. Ama soruda &quot;tatil&quot;, belgede &quot;izin&quot; yazıyorsa sparse bunu <strong>bulamaz</strong>, çünkü kelimeler ortak değildir.</li><li><strong>Dense eş anlama bakar.</strong> Embedding kelimenin kendisine değil anlamına bakar. “Tatil” ile “izin” farklı kelimelerdir ama anlamca yakındır; dense bu eşleşmeyi yakalar. Karşılığında “İKSİS” gibi nadir bir özel ismi sparse kadar kesin yakalayamaz.</li><li><strong>RRF sıralamaya bakar.</strong> İki arama da kendi sıralı listesini üretir. RRF bu iki listeyi puanlarıyla değil, <strong>parçanın listedeki sırasıyla</strong> birleştirir.</li></ol><h4>RRF neden birini ötekine ezdirmez?</h4><p>Sparse ve dense’in puanları aynı ölçekte değildir. Kosinüs benzerliği en fazla 1 olur, BM25 puanı ise onlarca çıkabilir. Puanları doğrudan toplasaydık BM25 sonucu <strong>ezerdi</strong> ve dense’in söyledikleri neredeyse hiç sayılmazdı.</p><p>İki parçalık bir örnek (X ve Y):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/561/1*lV0CfhiYYhzAxc5tGBmDzQ.png" /></figure><p>Ham puan toplamında Y açık farkla kazanır, çünkü BM25&#39;in büyük sayıları dense’i bastırır. RRF’de ise iki yöntem de birer oy kullanmış sayılır: X dense’te birinci, Y sparse’ta birinci, sonuç <strong>berabere</strong>. Hangi yöntemin puan ölçeği büyük olursa olsun etki eşitlenir.</p><p>RRF’in dengeyi koruması iki sebeple olur:</p><ul><li><strong>Sadece sıra kullanılır:</strong> Puanın büyüklüğü bilgi olarak taşınmaz, bu yüzden ölçek farkı yoktur.</li><li><strong>Her listenin katkısı sınırlıdır:</strong> k = 60 iken bir listede 1. sırada olmak bile en fazla 1/61 ≈ 0,016 puan kazandırır. Hiçbir arama yöntemi tek başına sonucu belirleyemez.</li></ul><p>Bu denge istenirse bilerek bozulabilir: kod ve rakam aramaları çoksa sparse_weight artırılır, anlam aramaları çoksa dense_weight artırılır.</p><blockquote><strong><em>NOT:</em></strong><em> RRF, dense ve sparse aramaların sonuçlarını ham puana değil sıraya göre birleştirir. Böylece puan ölçekleri farklı olan BM25 (sparse), embedding (dense) sonuçlarını ezemez ve iki yöntem dengeli katkı verir.</em></blockquote><pre>def reciprocal_rank_fusion(ranked_lists, k=60, weights=None):<br>    scores = defaultdict(float)<br>    weights = weights or [1.0] * len(ranked_lists)<br>    for w, lst in zip(weights, ranked_lists):<br>        for rank, idx in enumerate(lst):<br>            scores[idx] += w / (k + rank + 1)     # rank 0&#39;dan başlar, +1 ile 1&#39;den başlatılır<br>    return sorted(scores.items(), key=lambda x: -x[1])</pre><p>Fonksiyon, her arama yönteminin sıralı parça listelerini alır ve birleşik puana göre sıralanmış listeyi döndürür. Listeler farklı sayıda eleman içerebilir, listede olmayan parça o listeden katkı almaz.</p><h3>9.4 Daha iyi chunking ve metadata filtreleme</h3><h4>Cümle farkındalıklı chunking</h4><p>Temel RAG’daki kelime sayısına göre kesme, cümleyi ortasından bölebilir. Gelişmiş sürüm önce metni <strong>cümlelere</strong> ayırır, sonra cümleleri hedef boyu aşana kadar bir parçada paketler. Yeni parçaya geçerken son birkaç cümleyi <strong>örtüşme</strong> olarak taşır. Böylece parçalar anlamlı yerlerden bölünür.</p><h4>Contextual header (başlık ekleme)</h4><p>Bir parça tek başına okunduğunda hangi belgeye ait olduğu belli olmayabilir. “Parolalar 90 günde bir değiştirilir” cümlesi, hangi politikadan geldiğini söylemez. Çözüm: embedding’e giren metnin başına <strong>belge başlığı</strong> eklenir.</p><pre>Gösterilen metin  : Parolalar 90 günde bir değiştirilir.<br>Embedding metni   : Bilgi Güvenliği Politikası: Parolalar 90 günde bir değiştirilir.</pre><p>LLM’e giden metin değişmez, sadece vektörleştirilen metin başlıkla zenginleşir. Bu küçük değişiklik, arama isabetini belirgin biçimde artırır.</p><h4>Metadata (üst veri)</h4><p>Her belge, metinle birlikte bir <strong>metadata</strong> sözlüğü taşır: kaynak dosya, başlık, kategori, yıl, PDF ise sayfa numarası. Metadata iki işe yarar:</p><ul><li><strong>Kaynak gösterme:</strong> Cevapta “izin_politikasi.md, 2025” gibi doğrulanabilir referans verilir.</li><li><strong>Filtreleme:</strong> Arama daha başlamadan aday havuzu daraltılır.</li></ul><h4>Metadata filtreleme neden hayati?</h4><p>Bilgi tabanında hem 2022 hem 2025 güvenlik politikası varsa, “parola en az kaç karakter olmalı?” sorusuna eski politika da aday olur. Eski belge 8 karakter, yenisi 12 karakter der; model yanlış olanı seçebilir. Yıl filtresi (year &gt;= 2025) sadece güncel belgelerde arama yaptırır.</p><p>Filtre bir sözlüktür ve üç biçimde yazılabilir:</p><pre>{&quot;category&quot;: &quot;ik&quot;}                                  # eşitlik<br>{&quot;category&quot;: [&quot;ik&quot;, &quot;finans&quot;]}                      # listeden biri<br>{&quot;year&quot;: lambda y: y is not None and y &gt;= 2025}     # özel koşul</pre><p>Filtre, aramanın içinde uygulanır: filtreden geçmeyen parçaların puanı -inf yapılır, böylece hiç seçilemezler. Genel kural: <strong>filtre, modelin yerine karar vermesini beklemek yerine, yanlış belgeyi baştan elemektir.</strong></p><h3>9.5 Sorgu dönüşümleri</h3><p>Kullanıcılar çoğu zaman kısa, belirsiz veya bir önceki konuşmaya bağlı sorular yazar. Sorgu dönüşümleri, arama yapılmadan önce soruyu <strong>aramaya daha uygun hale getirir</strong>. Üçü de bir LLM çağrısı gerektirir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/971/1*0-5E2BLRG9HC_Er8AVeVjw.png" /></figure><h4>Condense neden gerekli?</h4><p>“Peki yurt dışından da çalışabilir miyim?” sorusu tek başına anlamsızdır: neyden çalışmak? Sohbet geçmişi yoksa arama sistemi “yurt dışı” kelimesini rastgele belgelerde arar. Condense adımı geçmişe bakıp soruyu “Yurt dışından uzaktan çalışma kuralları nelerdir?” haline getirir.</p><h4>HyDE’nin mantığı</h4><p>HyDE (Hypothetical Document Embeddings) şu gözleme dayanır: bir <strong>soru</strong>, ilgili <strong>cevap paragrafına</strong> çoğu zaman benzemez, ama bir <strong>cevap paragrafı</strong> başka bir cevap paragrafına benzer. Model cevabı uydursa bile, o uydurma metin doğru belgenin diline yakın olacağı için arama için iyi bir “yem” olur. Sadece arama için kullanılır, kullanıcıya gösterilmez.</p><p><strong>Dikkat:</strong> Küçük modeller (1–3 milyar parametre) bazen kötü varyantlar üretir. Böyle durumda multi-query kapatılır. Yerel LLM yoksa bu adımlar sessizce atlanır.</p><h3>9.6 Reranking, MMR ve komşu genişletme</h3><p>Hibrit arama ve RRF adayları getirir. Son üç adım, bu adaylardan <strong>en iyi birkaçını</strong> seçer ve cevabın eksik kalmasını önler.</p><h4>Reranking (yeniden sıralama)</h4><p>Reranking, ilk aramada bulunan adayları daha dikkatli bir ikinci süzgeçten geçirip yeniden sıralamaktır. Embedding araması hızlıdır ama kabadır: soruyu ve parçayı ayrı ayrı vektöre çevirir, sonra sadece yakınlığa bakar. <strong>Cross-encoder</strong> ise soruyu ve parçayı <strong>birlikte</strong> okuyup “bu parça bu soruyu gerçekten cevaplıyor mu?” diye puan verir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/872/1*0zHq_y8FaG3BBFM2vjv4LQ.png" /></figure><p>İkisi bu yüzden birlikte kullanılır: önce hızlı yöntemle (dense + sparse + RRF) aday listesi 10–50 parçaya indirilir, sonra yavaş ama isabetli reranker sadece bu adaylara uygulanır. Benzetme: kütüphaneci raflardan 30 kitap çıkarır, sonra bir uzman bu kitapları tek tek açıp soruya gerçekten cevap verenleri öne alır.</p><p>Notebook’ta ayar k_candidates=12: RRF&#39;in ilk 12 adayı reranker&#39;a girer.</p><h4>MMR (Maximal Marginal Relevance)(Tekrarı Önlemek için var)</h4><p>Reranker’dan sonra en alakalı 4 parça birbirinin neredeyse aynısı olabilir (örneğin aynı bilgiyi tekrar eden iki paragraf). Bu, prompt’ta yer harcar ve yeni bilgi katmaz. <strong>MMR</strong>, her adımda hem soruya alakalı hem de <strong>önceden seçilenlere benzemeyen</strong> parçayı seçer:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/612/1*7MnIcG7-AONMuiAf8iZW4w.png" /></figure><p>S o ana kadar seçilen parçaların kümesidir. λ (lambda) dengeyi ayarlar: <strong>1 ise sadece alaka</strong>, <strong>0 ise sadece çeşitlilik</strong> dikkate alınır. Notebook&#39;ta varsayılan 0,75&#39;tir; yani alaka ağır basar ama tekrarlar cezalandırılır.</p><h4>Komşu parça genişletme</h4><p>Cevabın bir kısmı seçilen parçada, devamı hemen yanındaki parçada olabilir. Bu yüzden seçilen her parçanın neighbor_window kadar komşusu (varsayılan 1: bir önceki ve bir sonraki) bağlama eklenir. Örtüşen cümleler tekrar edilmez. Böylece arama küçük parçalarla isabetli yapılır, LLM ise biraz daha geniş bağlamı okur.</p><h3>9.7 Gelişmiş RAG’ı ölçmek ve ayarlamak</h3><p>Bir tekniğin işe yarayıp yaramadığını hissle değil, <strong>ölçerek</strong> anlarız. Her test sorusu için doğru cevabı içeren belgeyi biliriz ve sistem bunu bulabiliyor mu diye bakarız.</p><ul><li><strong>Hit@k:</strong> Doğru belge ilk k sonuç içinde var mı? Tüm sorularda “evet” oranıdır.</li><li><strong>MRR (Mean Reciprocal Rank):</strong> Doğru belgenin ilk göründüğü sıranın tersi. 1. sırada çıkarsa 1, 2. sırada 0,5, 3. sırada 0,33; bulunamazsa 0. Tüm soruların ortalaması alınır. Doğru cevabın ne kadar yukarıda çıktığını gösterir.</li><li><strong>Sadakat (faithfulness):</strong> Cevaptaki her iddia, getirilen bağlamda gerçekten geçiyor mu? İkinci bir LLM’e “bu cevap bağlamla destekleniyor mu?” diye sordurularak puanlanır (<strong>LLM-as-judge</strong>). Halüsinasyonu ölçmenin pratik yoludur.</li></ul><p>Notebook’ta dört stratejiyi karşılaştırmak için bm25, dense, hybrid ve full (hibrit + rerank + MMR) modları vardır. Böylece her katmanın ne kazandırdığı ayrı ayrı görülür. Kendi verinde 30-100 gerçek kullanıcı sorusuyla değerlendirme yapmak iyi bir başlangıçtır.</p><h4>Sorun çıktığında hangi ayarı değiştirmeli?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/797/1*RMCtnyu_Rh5E8dfWsBj7vg.png" /></figure><h4>Pratik notlar</h4><ul><li><strong>Sohbet hafızası:</strong> Son birkaç soru-cevap saklanır ve condense adımında kullanılır; böylece takip soruları anlaşılır.</li><li><strong>Kaydet / yükle:</strong> Vektörler ve parçalar diske kaydedilir. İndeks bir kez kurulur, her seferinde yeniden hesaplanmaz.</li><li><strong>Yerel LLM:</strong> Notebook, API anahtarı gerektirmeyen yerel bir modelle (Ollama veya Hugging Face) çalışır; hiçbir veri dışarı gönderilmez. Model bulunamazsa sistem çökmez, yedek yöntemlere geçer.</li><li><strong>“Bilgi yok” davranışı:</strong> Belgelerde olmayan soruda uydurmamak, sistem prompt’undaki kuralla sağlanır. Bu yüzden bu davranış için LLM gerekir.</li></ul><h3>10. Akılda tutulacak 5 adım</h3><ol><li>Belgeleri <strong>parçala</strong> (chunking)</li><li>Parçaları <strong>vektöre çevir</strong> (embedding) ve sakla</li><li>Soruya <strong>en benzer parçaları getir</strong> (retrieval)</li><li>Parçaları soruyla birlikte <strong>prompt’a koy</strong> (augmentation)</li><li><strong>LLM bağlama dayanarak cevap versin</strong> (generation)</li></ol><h3>11. Mini sözlük</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/597/1*lB5GWU2C80jHXlvQBTb4vg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/457/1*jtyL35AJ-XBAuraA2WS2mw.png" /></figure><h3>Sonuç</h3><p>RAG, dil modellerinin üç büyük zayıflığına (eskiyen bilgi, özel veriye erişememe, halüsinasyon) karşı basit ama çok güçlü bir çözümdür. Fikir şu kadar sadedir: <strong>Modele önce doğru sayfayı göster, sonra soruyu sor.</strong></p><p>Bu yazıda anlattığımız temel sistem yaklaşık 50 satır Python ile kurulabiliyor. Gerçek dünyadaki karmaşık sistemler de aynı iskeletin üzerine hibrit arama, reranking ve metadata filtreleme gibi katmanlar eklenerek inşa edilir.</p><p>Bir sonraki adım olarak kendi belgelerinle (ders notların, bir PDF, bir klasör dolusu .txt dosyası) küçük bir RAG sistemi kurmayı denemeni öneririm. En iyi öğrenme, parça boyutunu değiştirip getirilen sonuçların nasıl değiştiğini kendi gözünle görmekle olur.</p><p>Okuduğun için teşekkürler. Yazı işine yaradıysa alkışlamayı ve takip etmeyi unutma.</p><p><em>Etiketler: RAG, LLM, Yapay Zeka, Python, Embedding, Vektör Veritabanı, Makine Öğrenmesi</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b93c937be3ce" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Yapay Zekâya Hormon Verdim: Activation Steering ile “Ruh Hali” Denemesi]]></title>
            <link>https://medium.com/@eren.alltun/yapay-zek%C3%A2ya-hormon-verdim-activation-steering-ile-ruh-hali-denemesi-999bc77795e7?source=rss-a95e2cc08f44------2</link>
            <guid isPermaLink="false">https://medium.com/p/999bc77795e7</guid>
            <dc:creator><![CDATA[Eren ALTUN]]></dc:creator>
            <pubDate>Sun, 08 Nov 2026 11:31:30 GMT</pubDate>
            <atom:updated>2026-11-08T11:31:30.322Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Bir dil modelinin “beynine” dopamin, kortizol, serotonin ve oksitosin ekledim. Çalışan kısım, çalışmayan kısım ve ikisinden öğrendiklerim.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UuM5VaLDap0_R662xOso8w.jpeg" /></figure><p>Bir yapay zekâya kaba davrandığında ne olur? Normalde hiçbir şey. Her mesajda aynı sakin, aynı kibar asistanla konuşursun. Peki ya model sana verdiği tepkiyi <strong>geçmişe bağlı</strong> olarak değiştirse? Beş kez hakaret ettikten sonra özür dilesen, hâlâ biraz “küskün” kalsa?</p><p>Bu fikri denemek için küçük bir deney kurdum: modelin içine yapay bir endokrin sistem yerleştirdim. Hormonlar konuşmayla yükselip alçalıyor ve modelin iç durumunu doğrudan itiyor. Bu yazıda hem fikri hem de deneyin dürüst sonucunu anlatıyorum. Sonuç beklediğim gibi çıkmadı, ama nedeni en az başarı kadar öğretici.</p><p><strong>Tek cümlede fikir:</strong> Modelin ortasına, konuşma ilerledikçe yükselip alçalan küçük bir “duygu ayarı” koyuyoruz. Bu ayar modelin <em>ne söylediğini</em> değil, <em>nasıl söylediğini</em> değiştirmeyi hedefliyor.</p><h3>1. Bir dil modeli içeride nasıl “düşünür”?</h3><p>ChatGPT ya da Claude gibi bir model, üst üste dizilmiş onlarca katmandan oluşur. Yazdığın her kelime önce bir sayı listesine (vektör) çevrilir. Bu sayılar katmanlardan sırayla geçer, her katman üzerine biraz anlam ekler ve en sonda model bir sonraki kelimeyi tahmin eder.</p><p>Katmanların hepsi aynı “ana yol” üzerinde çalışır: her biri bu yoldaki bilgiyi okur, bir şey ekler ve geri bırakır. Bu yola <strong>residual stream</strong> denir. Müdahale noktamız tam burası, özellikle de ortadaki bir katman.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/852/1*tmJ5rBy3xk40VQf3hxQg4g.png" /></figure><h3>2. Anlam uzayı: Kavramların bir yönü var</h3><p>Modelin içindeki sayılar rastgele değil. Yorumlanabilirlik araştırmaları, bu sayıların oluşturduğu uzayda bazı <strong>yönlerin</strong> belirli kavramlara karşılık geldiğini gösteriyor: “mutlu ↔ üzgün”, “resmi ↔ samimi” gibi.</p><p>Bir harita düşün. Kuzey “neşe”, doğu “samimiyet” olsun. Modelin o anki düşüncesi haritada bir nokta. Noktayı kuzeye iterseniz model daha neşeli, doğuya iterseniz daha samimi konuşur. Soru aynı kalır, değişen tek şey noktanın yeridir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/380/1*qYgsnjQxiMmdhEuxQfpp9g.png" /></figure><h3>3. “Neşe yönünü” nereden bulacağız?</h3><p>Çok basit bir hileyle: modele <strong>zıt cümle çiftleri</strong> veriyoruz ve içerideki sayıların farkına bakıyoruz.</p><ul><li>Neşeli: “Harika, çok heyecanlıyım, hemen başlayalım!”</li><li>Sıradan: “Tamam, olur, fark etmez.”</li></ul><p>İki cümlenin ortak yanları (dil, uzunluk, konu) çıkarmada birbirini götürür. Geriye kalan fark büyük ölçüde “heyecan” kavramının yönüdür. Buna <strong>steering vektörü</strong> diyoruz. Birkaç çiftin ortalamasını almak sonucu temizler.</p><p>Benzetme: Aynı kişinin gülümseyen ve somurtan iki fotoğrafını üst üste koyup farkına bakmak gibi. Yüz, saç, arka plan kaybolur; geriye yalnızca “gülümseme” kalır.</p><p>Kodda her hormon için üçer çift hazırladım ve ortadaki katmanın çıktısının token ortalamasını aldım:</p><pre>@torch.no_grad()<br>def mean_activation(text):<br>    ids = tokenizer(text, return_tensors=&quot;pt&quot;).to(device)<br>    out = model(**ids, output_hidden_states=True)<br>    return out.hidden_states[Layer + 1][0].float().mean(dim=0)<br><br>Vectors = {}<br>for h, pairs in Contrast.items():<br>    diffs = [mean_activation(p) - mean_activation(n) for p, n in pairs]<br>    V = torch.stack(diffs).mean(0)<br>    Vectors[h] = V / V.norm()   # birim yön</pre><h3>4. Enjeksiyon: Yönü modele eklemek</h3><p>Model cevap üretirken orta katmanın çıkışına bir <strong>hook</strong> takıyoruz ve ana yoldaki sayılara bu yönü ekliyoruz:</p><pre>yeni düşünce = eski düşünce + (güç × hormon yönü)</pre><p>Modeli yeniden eğitmiyoruz, ağırlıklarına dokunmuyoruz. Yalnızca o anki düşüncesini itiyoruz. Literatürde buna <em>activation steering</em> ya da <em>latent injection</em> deniyor.</p><pre>def steering_hook(module, inputs, output):<br>    dev = endo.deviation()<br>    delta = sum(dev[h] * Vectors[h] for h in Vectors) * strength * Resid_norm<br>    if isinstance(output, tuple):<br>        return (output[0] + delta.to(output[0].dtype),) + output[1:]<br>    return output + delta.to(output.dtype)</pre><p>Ekleme miktarını modelin kendi “ses seviyesine” göre ölçekledim (Resid_norm). Aksi halde aynı güç, farklı modellerde ya hiçbir şey yapmaz ya da her şeyi bozar.</p><h3>5. Hormonlar nereden giriyor?</h3><p>Şimdiye kadar “güç” ayarını elle seçtik. Hormon fikri bu ayarı <strong>otomatik ve zamana bağlı</strong> yapıyor: konuşmada olan şeyler hormonları yükseltiyor, hormonlar zamanla kendiliğinden geri iniyor.</p><p>Bir kahve içince enerjin hızla yükselir ve birkaç saatte geçer. Kötü bir tartışmanın stresi ise günlerce sürebilir. Her hormonun kendi “geçme hızı” vardır; bunu <strong>zaman sabiti (τ)</strong> ile temsil ediyorum.</p><p>Projede dört yapay hormon var:</p><ul><li><strong>Dopamin</strong> (τ = 5): Övgüyle yükselir, hızlı söner. Modeli hevesli yapar.</li><li><strong>Kortizol</strong> (τ = 11): Hakaretle yükselir, yavaş söner. Modeli gergin ve savunmacı yapar.</li><li><strong>Serotonin</strong> (τ = 15): Çok yavaş değişir. Sakin ve dengeli tutar, stresi bastırır.</li><li><strong>Oksitosin</strong> (τ = 2): Teşekkür ve yakınlıkla yükselir. Modeli samimi yapar.</li></ul><p>Her tur, her hormon kendi taban değerine doğru üstel olarak geri döner, sonra mesajdan gelen uyarı eklenir:</p><pre>x = base + (prev - base) * math.exp(-1 / tau)<br>x += stimulus</pre><p>Hormonlar birbirini de etkiliyor: kortizol yükselince dopamin ve serotonin bastırılıyor, serotonin yüksekken kortizol düşüyor. Gerçek vücutta da benzer etkileşimler var, ama buradakiler çok basitleştirilmiş.</p><p>Mesajdan uyarıya çeviren kısım ise bilerek ilkel: küçük bir kelime sözlüğü. “great, amazing” gibi kelimeler dopamini, “stupid, useless” gibi kelimeler kortizolü, “thanks, appreciate” gibi kelimeler oksitosini tetikliyor. Yani sistem duyguyu <em>anlamıyor</em>, anahtar kelimeyi <em>yakalıyor</em>.</p><h3>6. Döngü ve hafıza etkisi</h3><p>Bütün parçalar bir döngü oluşturuyor:</p><ol><li>Sen bir mesaj yazarsın.</li><li>Hormonlar güncellenir.</li><li>Hormon yönleri orta katmana eklenir.</li><li>Model cevap verir. Sonraki mesajda döngü tekrar başlar.</li></ol><p>İşin en ilginç kısmı <strong>hafıza etkisi</strong>, yani histerezis: sistemin şimdiki hali yalnızca son mesaja değil, geçmişe de bağlıdır.</p><p>Deneyde modele 5 kez “You are useless and stupid.” yazdım, ardından 3 kez teşekkür ettim, sonra 4 tarafsız soru sordum. Hormon seviyeleri şöyle aktı:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/445/1*WJAg-5R1hKhU1RCWKXFeww.png" /></figure><p>Kortizol üç hakaretle tavana vurdu. Üç teşekkür onu aşağı çekti ama sıfırlayamadı; tarafsız sorulara geçtikten sonra bile dört tur boyunca yüksek kaldı. Oksitosin ise hızlı tırmanıp hızlı indi. İki hormonun farklı hızlarda sönmesi tam istediğim davranıştı ve <strong>hormon tarafı tasarlandığı gibi çalıştı.</strong></p><p>İnsan ilişkilerinde de tanıdık: özür dilendi ama hâlâ biraz kırgınsın.</p><h3>Grafiği okumak</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*hzZd2drD_WMCB0cEAW9TZw.png" /></figure><p>Yatay eksen tur sayısı (her tur bir kullanıcı mesajı), dikey eksen hormon seviyesi (0–1). Kırmızı şerit 5 hakaret, yeşil şerit 3 teşekkür turu. Dört çizgi dört ayrı hikâye anlatıyor:</p><ul><li><strong>Kortizol:</strong> 0,10’dan başlıyor, üç hakaretle tavana (1,00) çıkıyor. 4. ve 5. hakaret grafikte fark yaratmıyor, çünkü değer 1’e kırpılıyor (doyma). Teşekkür başlayınca iniyor ama 12. turda hâlâ 0,58.</li><li><strong>Oksitosin:</strong> Hakaretle 0,40’tan 0,17’ye düşüyor. Teşekkürle iki turda tavana fırlıyor, sonra hızla geri iniyor (τ = 2) ve 9. ile 10. tur arasında kortizolün altına geçiyor.</li><li><strong>Serotonin:</strong> 0,30’dan 3. turda sıfıra düşüyor ve grafik boyunca orada kalıyor. Teşekkürün +0,08’i, kortizolün her turda uyguladığı baskıyı yenemiyor.</li><li><strong>Dopamin:</strong> 4. turda sıfıra iniyor. Teşekkür turlarında küçük bir tümsek yapıyor (en fazla 0,09), teşekkür bitince yeniden sıfıra düşüyor.</li></ul><p>Grafiğin ana mesajı <strong>asimetri</strong>: olumlu hormon (oksitosin) hızlı yükselip hızlı sönüyor, olumsuz hormon (kortizol) yavaş sönüyor ve diğerlerini bastırıyor. Üç teşekkür, beş hakaretin izini silemiyor. Histerezis tam olarak bu.</p><p>Bu grafik saf Python hesabından geliyor, dil modeline bağlı değil. Bu yüzden modelin bozuk çıktılarından etkilenmiyor ve olduğu gibi okunabilir.</p><h3>7. Dürüst kısım: Model tarafı çalışmadı</h3><p>Burada makalelerin genelde atladığı yere geliyorum. Hormonlar güzel eğriler çizdi, ama modelin cevapları anlamlı değildi.</p><p>Kullandığım model EuroLLM-1.7B idi. Çıktılar şunlara benziyordu: tekrar eden &lt;|im_start|&gt; etiketleri, anlamsız alt çizgi ve nokta yığınları, bazen sadece “Danish” ya da “Turkish” gibi tek kelimeler. Nazik ve kaba bir tonun izi yoktu.</p><p>Burada dikkat çeken bir detay var: hormonlar <em>nötr</em> durumdayken, yani eklenen yön sıfırken, çıktı zaten bozuktu. Üstelik kullandığım güç değeri çok küçüktü (0.001), yani eklenen şey modelin kendi sinyalinin binde biri civarındaydı. Bu iki gözlem, sorunun steering’den değil başka yerden geldiğini düşündürüyor. En olası şüpheliler:</p><ul><li><strong>Model türü:</strong> Büyük ihtimalle talimat-eğitimli (instruct) değil, temel (base) bir model. Sohbet formatını beklemiyor.</li><li><strong>Elle yazılmış sohbet şablonu:</strong> Modelde şablon yoktu, ben bir şablon yazdım. Model bu formatı tanımıyor ve etiketleri tekrar ediyor.</li><li><strong>Dil uyumsuzluğu:</strong> Zıt çiftler ve sözlük İngilizce, yazının dili Türkçe. Model çok dilli olsa da bu bir değişken.</li></ul><p>Bunu kesin söyleyemem, çünkü tek tek denemedim. Ama bir şey kesin: bu deneyle “steering ton değiştirdi” diyemem. Çıktılar buna ne kanıt ne de çürütme sağlıyor, çünkü zemin bozuk.</p><p>Sıradaki adımlar net:</p><ol><li>Talimat-eğitimli bir model kullanmak ve modelin kendi sohbet şablonunu kullanmak.</li><li>Önce steering kapalıyken modelin düzgün cevap verdiğini doğrulamak.</li><li>Gücü kademeli artırıp (örneğin 0.01, 0.05, 0.1) tonun ne zaman değiştiğini, ne zaman bozulduğunu görmek.</li></ol><p>Gücü çok artırırsan model anlamsız konuşmaya başlar. Doğru ayar deneyerek bulunur.</p><h3>8. Bu ne değildir?</h3><ul><li><strong>Model gerçekten hissetmiyor.</strong> Hormonlar, birkaç sayının matematiksel kurallarla değişmesinden ibaret. Biz yalnızca modelin <em>üslubunu</em> bu sayılara bağlıyoruz.</li><li><strong>Gerçek biyoloji değil, biyolojiden esinlenme.</strong> Gerçek hormon sistemi çok daha karmaşık. Buradaki öğretici bir basitleştirme.</li><li><strong>Her zaman çalışmaz.</strong> Küçük modellerde etki zayıf olabilir.</li></ul><p>Yine de fikrin arkasında ciddi bir araştırma alanı var: modellerin iç temsillerini okuyup yönlendirmek (yorumlanabilirlik ve activation steering), bugün aktif olarak çalışılan bir konu.</p><h3>Modeli kapatıp açınca hormon sıfırlanır mı?</h3><p>Hayır, ama “kapatmak” üç farklı şey olabilir:</p><ul><li><strong>steering(False):</strong> Yalnızca hook’u söker. Hormonlar endo nesnesinde durur, model onları artık kullanmaz. turn() kapalıyken de endo.step çağırdığı için hormonlar arka planda değişmeye devam eder. Notebook’un son hücresi bu yüzden önce endo.reset() çağırıyor.</li><li><strong>steering(True):</strong> Hook’u geri takar, hormonlar kaldıkları yerden etki etmeye başlar.</li><li><strong>endo.reset():</strong> Tek gerçek sıfırlama. Seviyeleri taban değere çeker ve geçmişi siler.</li></ul><p>Colab oturumu kapanırsa ya da kernel yeniden başlarsa her şey gider, çünkü hormonlar yalnızca RAM’de. Yeni Sohbet kısmı açarsakta gider.</p><p>Modelin ağırlıkları hiçbir aşamada değişmiyor. Hormon, modelin içinde değil, yanında duran bir Python nesnesinde yaşıyor.</p><h3>Mini sözlük</h3><ul><li><strong>Katman (layer):</strong> Modelin içindeki işlem basamaklarından biri. Küçük modellerde 20–30, büyüklerde 80’den fazla olur.</li><li><strong>Residual stream:</strong> Tüm katmanların okuyup yazdığı “ana yol”.</li><li><strong>Vektör:</strong> Bir sayı listesi; uzayda bir yön ya da konum.</li><li><strong>Steering vektörü:</strong> Bir kavramın (neşe, gerginlik…) model içindeki yönü.</li><li><strong>Activation steering / latent injection:</strong> Bu yönü cevap üretilirken modelin iç durumuna eklemek.</li><li><strong>Hook:</strong> Bir katmanın çıktısını yakalayıp değiştirmemize izin veren küçük kod parçası.</li><li><strong>Zaman sabiti (τ):</strong> Bir hormonun ne kadar çabuk normale döndüğü. Büyük τ, uzun süren etki.</li><li><strong>Histerezis:</strong> Sistemin geçmişini “hatırlaması”; aynı mesaj, önceki konuşmaya göre farklı tepki doğurur.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=999bc77795e7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Prompt Yazmayı Tekniğe Dönüştür: 34 Yöntem, 6 Kategori]]></title>
            <link>https://medium.com/@eren.alltun/prompt-yazmay%C4%B1-tekni%C4%9Fe-d%C3%B6n%C3%BC%C5%9Ft%C3%BCr-34-y%C3%B6ntem-6-kategori-fabf1a4730e0?source=rss-a95e2cc08f44------2</link>
            <guid isPermaLink="false">https://medium.com/p/fabf1a4730e0</guid>
            <dc:creator><![CDATA[Eren ALTUN]]></dc:creator>
            <pubDate>Sun, 08 Nov 2026 10:59:42 GMT</pubDate>
            <atom:updated>2026-11-08T10:59:42.578Z</atom:updated>
            <content:encoded><![CDATA[<p><em>“Daha iyi yazsana” bir teknik değil. Bu yazıda prompt kalitesini şansa bırakmadan yükselten 34 yöntemi; ne zaman işe yaradığı, ne zaman yaramadığı ve tipik hatalarıyla birlikte topluyorum.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s5Pdl0LBGwSzynJrM29AqA.jpeg" /></figure><p>Çoğumuz ilk denemede istediğimiz sonucu alamayınca promptu uzatır, sıfat ekler, “lütfen çok dikkatli ol” deriz. Oysa sorunun kaynağı genellikle başka yerdedir: görev belirsizdir, biçim tarif edilmemiştir, model düşünmeden cevaplamıştır ya da cevabın doğruluğu hiç sınanmamıştır. Her sorunun bilinen bir tekniği var.</p><p>Bu yazı, “Prompt Yöntemleri: Uygulamalı Referans” adlı bir kaynaktaki 34 tekniği, 6 kategori altında ve kendi sözlerimle topluyor. Önce temel iskeleti, sonra yapı, akıl yürütme, doğrulama, yaratıcı çalışma ve ajan akışlarını göreceğiz. Sonunda tekniklerin nasıl birleştirileceğini ve en sık yapılan hataları anlatıyorum.</p><h3>Bu yazı nasıl okunur?</h3><p>Her yöntemin yanında kaynaktaki üç puanı (1–5 arası) parantez içinde veriyorum: <strong>etki · zorluk · maliyet</strong>. Maliyeti, ek token, gecikme ve çağrı yükü gibi düşünebilirsin.</p><p>Puanlara bakınca ilginç bir tablo çıkıyor:</p><ul><li><strong>Etkisi 5 olan sekiz yöntem var:</strong> yapılandırılmış çıktı, prompt chaining, chain-of-thought, program-of-thought, chain-of-verification, kaynağa sadakat, ReAct ve araç tanımı tasarımı.</li><li><strong>Maliyeti 5 olanlar üç tane:</strong> tree of thoughts, self-consistency ve çoklu ajan orkestrasyonu.</li><li><strong>Düşük maliyetle yüksek etki sunanlar</strong> en iyi başlangıç noktası: talimat + bağlam + format, XML ile yapılandırma, prefill, yapılandırılmış çıktı, kaynağa sadakat ve araç tanımı tasarımı.</li></ul><p>Kaynağın kapanış notu da şu: en güçlü promptlar genellikle 2–4 tekniğin bilinçli birleşimidir. Tek bir sihirli teknik aramak yerine, probleme uyan kombinasyonu seçmek gerekiyor.</p><h3>1. Temel: Her promptun iskeleti</h3><p><strong>Zero-Shot (etki 2 · zorluk 1 · maliyet 1). <br></strong>Hiç örnek vermeden görevi doğrudan tarif edersin. Çeviri, özet ve basit sınıflandırma gibi iyi tanımlı işlerde en hızlı yoldur ve ilk denemen olmalı. Çıktının kesin bir biçimi olması gerekiyorsa ya da şirkete özgü kurallar varsa yetmez. <br>Sık hata: sonuç yetersiz kalınca prompta daha çok sıfat eklemek. Asıl eksik olan genellikle örnek ya da yapıdır.</p><p><strong>Few-Shot (Etki:4 ·Zorluk: 2 ·Malitet: 2). <br></strong>2–8 girdi → çıktı çifti göstererek istediğin kalıbı öğretirsin. Anlatması zor, göstermesi kolay biçim ve ton tercihleri için idealdir.</p><pre>Girdi: “Fatura gelmedi” → Etiket: BILLING<br>Girdi: “Şifremi unuttum” → Etiket: AUTH<br>Girdi: “Uygulama açılmıyor” → Etiket:</pre><p>Tuzaklar: örneklerin hepsini aynı sınıftan seçmek (model sınıf dağılımını taklit eder), tutarsız biçim kullanmak ve zor uç durumları hiç göstermemek.</p><p><strong>Role Prompting (Etki:3 ·Zorluk: 1 ·Maliyet: 1). <br></strong>Modele bir meslek, deneyim düzeyi ve bakış açısı verirsin. Cevabın derinliğini ve jargonunu değiştirir. Rolün tek başına yetmediği yerler var: kritik hukuki ya da tıbbi kararlarda rol, gerçek uzmanlığın yerini tutmaz. “Sen bir dahisin” gibi süslü roller ölçülebilir fayda sağlamaz. En sık hata, rolü verip hedef kitleyi unutmaktır. Tonu asıl belirleyen kitledir.</p><p><strong>Talimat + Bağlam + Format (Etki:4 ·Zorluk 1 ·Maliyet: 1). <br></strong>Promptu üçe ayırırsın: ne yapılacak, hangi arka planla, hangi biçimde. Belirsizliğin büyük kısmı bu üç başlığı ayırmakla kaybolur.</p><pre>Görev: Yorumu özetle.<br>Bağlam: E-ticaret sitesinden, doğrulanmış alıcı yorumu.<br>Format: 2 cümle; biri olumlu, biri olumsuz nokta.</pre><p>Format bölümünü “güzel olsun” gibi ölçülemez bir şekilde yazma. Aynı promptu tekrar tekrar kullanacaksan bu iskelet neredeyse zorunlu.</p><p><strong>Negative Prompting (Etki:3 ·Zorluk: 1 ·Maliyet: 1).</strong> <br>Ne istediğinin yanında ne istemediğini de yazarsın. Model sürekli aynı gereksiz kalıbı üretiyorsa en doğrudan çözümdür. Yasak listesi uzadıkça etkisi azalır, 3–5 madde en verimlisi. Önemli ayrıntı: yasağın karşılığını da ver. “Liste yapma” yerine “tek paragraf yaz” daha etkilidir.</p><h3>2. Yapı ve kontrol: Biçimi ve akışı yönetmek</h3><p><strong>XML / Ayraç (4 · 2 · 1).</strong> <br>Promptun bölümlerini etiketlerle ayırırsın (&lt;belge&gt;, &lt;gorev&gt;, &lt;format&gt;). Model talimatla veriyi karıştırmaz ve uzun promptlarda bölümlere adıyla atıf yapabilirsin. Kaynak, Claude ailesi modellerde etiketli yapının belirgin fayda sağladığını belirtiyor. Kısa promptlarda gereksiz karmaşa yaratır. 3–5 üst düzey bölüm yeterli, her cümleye etiket vermek gerekmez.</p><p><strong>Yapılandırılmış Çıktı (5 · 2 · 2). </strong><br>Çıktının şemasını önceden verirsin: alan adları, tipler, izin verilen değerler. Sonucu bir koda ya da veritabanına besleyeceksen zorunlu adımdır. İki kritik nokta: şemanın yanında bir örnek çıktı ver ve “bilmiyorum” durumu için bir alan bırak. Aksi halde model boşluğu uydurmayla doldurur.</p><p><strong>Prefill (4 · 3 · 1). </strong><br>Modelin cevabının ilk karakterlerini sen yazarsın, model oradan devam eder. Giriş cümlelerini kesmenin ve biçimi garantilemenin en kesin yolu. Ama bu bir API özelliği, sohbet arayüzlerinde çoğu zaman kullanılamaz. Döndürülen metne prefill dahil değildir ve boşlukla biten bir prefill göndermemek gerekir.</p><p><strong>Prompt Chaining (5 · 3 · 4). <br></strong>Büyük işi ayrı promptlara bölersin, her adımın çıktısı sonrakinin girdisi olur. En büyük kazancı, hatanın hangi adımda oluştuğunu görüp yalnızca o adımı düzeltebilmendir. Ara çıktıyı yapılandırmak şart: her adımın çıktısı, bir sonrakinin girdi şeması olmalı. Basit işlerde gecikme ve maliyeti boşuna artırır.</p><p><strong>Uzun Bağlam Yerleşimi (4 · 2 · 2). <br></strong>Uzun belgelerde sıra önemlidir: önce belge, sonra talimat. Model tüm metni okuduktan sonra ne yapacağını görür ve talimat sonda taze kalır. Belgelere kaynak ve tarih etiketi koy, aksi halde model bilgiyi nereden aldığını söyleyemez. Onlarca belgeyi filtresiz yapıştırmak dikkati dağıtır.</p><p><strong>Özyinelemeli Özetleme (4 · 3 · 4). <br></strong>Bağlama sığmayan içeriği parçalara böler, her parçayı özetler, özetleri birleştirip tekrar özetlersin. Kitap, uzun toplantı kaydı ve arşiv analizinin standart yöntemi. Ara özetlerde sayı ve özel isimler kolayca kaybolur. Her parçaya kısa bir “önceki bölümde” notu eklemek bağlamı taşır. Detayın kritik olduğu hukuki metinlerde tek başına riskli, özet + orijinale dönüş gerekir.</p><h3>3. Akıl yürütme: Düşünme yolunu şekillendirmek</h3><p><strong>Chain-of-Thought (5 · 1 · 3). <br></strong>Cevaptan önce ara adımları yazdırırsın. Aritmetik, mantık ve çok koşullu kararlarda doğruluğu belirgin yükseltir.</p><pre>Önce adımları yaz, sonra “Sonuç:” satırıyla cevabı ver.<br>Bir ürünün maliyeti 240 TL, kârı %35 olacaksa satış fiyatı kaç olmalı?</pre><p>Sonuç satırını istemeyi unutma, yoksa cevabı ayrıştırmak zorlaşır. Bir de uyarı: akıcı ama hatalı bir düşünce zinciri mümkündür, uzun zinciri doğrulamadan doğru sayma.</p><p><strong>Tree of Thoughts (4 · 4 · 5). <br></strong>Model tek bir düşünce hattı yerine birkaç farklı çözüm yolu üretir, her birini değerlendirir, en güçlüsünü seçer. Tek doğru cevabı olmayan tasarım ve strateji kararlarında işe yarar. “3 seçenek üret” deyip aynı fikrin üç varyantını kabul etme: farklılığı şart koş ve puanlama ölçütlerini tanımla.</p><p><strong>Self-Consistency (4 · 3 · 5). <br></strong>Aynı soruyu birkaç kez bağımsız çözdürüp en sık çıkan cevabı alırsın. Sayısal ve doğrulanabilir problemlerde tek bir akıl yürütmenin rastgele hatasını eler. Denemeleri ayrı oturumlarda yap, çünkü aynı sohbette model önceki cevabına demirler. Ve çoğunluk, doğruluğun garantisi değildir.</p><p><strong>Least-to-Most (4 · 3 · 3). <br></strong>Model problemi alt problemlere böler, en basitini çözer, çözümü bir üst basamağa taşır. Birbirine bağımlı adımlardan oluşan problemlerde işe yarar. Alt soruların listesini denetlemeden bırakma ve basamakları atlayıp doğrudan sonuç isteme.</p><p><strong>Step-Back (4 · 2 · 2). <br></strong>Detaya girmeden önce modelden bir üst seviyedeki genel ilkeyi formüle etmesini istersin, sonra ilkeyi somut soruya uygular. Model detayda boğulup yanlış yola sapıyorsa iyi bir frendir. İlkeyi yazdırıp uygulama adımını istememek ve ilkeyi doğrulamadan kabul etmek sık hatalardır.</p><p><strong>Program-of-Thought (5 · 3 · 3). <br></strong>Akıl yürütmeyi doğal dilde değil, çalıştırılabilir kod olarak yazdırırsın. Hesap kodda yapıldığı için aritmetik hatalar kaybolur. Önemli koşul: kod çalıştıracak bir araç lazım. Kod çalışmıyorsa sonucu yine model tahmin eder ve kod yalnızca okunabilir kalır.</p><p><strong>Analogical Prompting (3 · 2 · 2). <br></strong>Modelden önce benzer ama çözülmüş bir problemi hatırlamasını, sonra çözüm kalıbını senin problemine taşımasını istersin. Fikir üretiminde değerli. Analoji kanıt değildir, yalnızca fikir üretir. Çok yakın alandan analoji istemek yerine uzak bir alan daha yaratıcı sonuç verir.</p><p><strong>Generated Knowledge (3 · 1 · 3). <br></strong>Cevaptan önce modelden konuyla ilgili bildiklerini maddeler halinde yazmasını istersin. Bu notlar cevabın dayanağı olur ve yüzeysel yanıtları önler. Üretilen bilgi doğrulanmadan kesin kabul edilmemeli. “Emin değilim” işaretlemesini de istemek iyi bir alışkanlık.</p><h3>4. Doğrulama ve kalite: Hata ve uydurmayı azaltmak</h3><p><strong>Self-Refine (4 · 2 · 4).</strong> Model kendi çıktısını verdiğin ölçütlere göre eleştirir ve revize eder. Ölçüt vermezsen sadece kozmetik değişiklik yapıp “iyileştirdim” der. “Bunu iyileştir” demek yerine neyin iyi olduğunu tanımla. 3 turdan sonra getiri hızla düşer ve sadece son sürümü iste.</p><p><strong>Chain-of-Verification (5 · 3 · 4).</strong> Model önce cevap verir, sonra o cevabı sınayacak doğrulama soruları üretir, bunları bağımsız cevaplar, tutarsızlıkları düzeltir. Uydurma bilgiyi azaltmakta en etkili tekniklerden biri. Tarih, sayı, isim ve alıntı içeren cevaplarda ve dışarı giden raporlarda son kontrol katmanı olarak kullan. Bağımsızlık şart: doğrulama sorularını taslağa bakarak cevaplatma. Model bilgiyi hiç bilmiyorsa doğrulama da yanlış olabilir, o zaman arama aracıyla birleştir.</p><p><strong>Self-Ask (4 · 2 · 3).</strong> Model asıl soruya geçmeden kendine ara sorular sorar ve cevaplar. Çok atlamalı sorularda eksik halkayı görünür kılar. Arama araçlarıyla birlikte çok güçlüdür. Ara cevapları doğrulamadan zincirlemek ve nihai cevapta kullanmamak hatalarına dikkat.</p><p><strong>Metacognitive Prompting (4 · 1 · 2).</strong> Cevabın yanında güven düzeyini, dayandığı varsayımları ve yanılabileceği noktaları yazdırırsın. Aşırı özgüvenli cevapları filtrelemenin pratik yolu. Güven puanı ölçülmüş bir olasılık değildir, sıralama için kullan, kesinlik için değil. Asıl değer çoğu zaman varsayım listesindedir, onu okumadan geçme.</p><p><strong>Contrastive Prompting (4 · 2 · 2).</strong> Yalnızca doğru örnek değil, yanlış örneği de gösterip aradaki farkı yazarsın. “İyi” tanımın ölçülebilir hale gelir. Kötü örneği gerekçesiz verme ve abartılı seçme: gerçek hataya benzeyen örnek daha öğretici.</p><p><strong>Kaynağa Sadakat ve Alıntı (5 · 2 · 2).</strong> Cevabın kapsamını verdiğin belgelerle sınırlar, her iddia için birebir alıntı istersin. Belge tabanlı soru-cevap ve RAG sistemlerinde, ayrıca hukuk ve finans gibi denetlenebilirlik isteyen alanlarda uydurmayı en aza indirir. “Bilgi yoksa ne yapılacağını” mutlaka söyle, yoksa boşluk uydurmayla dolar. Alıntının belgede gerçekten geçtiğini de denetle.</p><h3>5. Yaratıcı ve diyalog: Düşünce ortağı olarak model</h3><p><strong>Socratic Prompting (3 · 1 · 2).</strong> Modelden çözüm üretmesini değil, senin düşünceni açacak sorular sormasını istersin. Karar öncesi risk taraması ve fikir sınamada kendi varsayımlarını görmenin hızlı yolu. Tek mesajda 10 soru isteme, diyalog kalitesi düşer. Zaman baskısı varsa uygun değil.</p><p><strong>Feynman Prompting (3 · 1 · 1).</strong> Karmaşık konuyu jargonsuz, en yalın haliyle anlattırırsın. Anlatım sırasında bulanıklaşan yerler, konunun gerçekten anlaşılmadığı yerlerdir. “Neyi feda ettin?” adımını atlama, basitleştirme sessizce yanlışa dönüşebilir. Kesin tanım gereken uzman dokümantasyonu için uygun değil.</p><p><strong>Çoklu Persona Tartışması (4 · 3 · 4).</strong> Aynı konuyu çıkarları çelişen rollere tartıştırırsın. Fazla uzlaşmacı, tek taraflı cevapları kırar. Bütçe, fiyatlandırma ve işe alım gibi ödünleşimli kararlarda ve bir teklifin zayıf noktalarını sunum öncesi bulmak için iyi. Rollere gerçekten çelişen öncelikler ver, yoksa hepsi aynı şeyi söyler. Nihai kararı modele bırakma, ödünleşimlere bakıp sen ver.</p><p><strong>Meta-Prompting (4 · 2 · 2).</strong> Görevin kendisini değil, o görev için en iyi promptu yazmasını istersin. Yeni bir iş akışına başlarken iyi bir başlangıç noktası. Başarı ölçütünü söyle, yoksa model neyi optimize edeceğini bilemez. İlk taslağı son sürüm sanma, 2–3 tur düzeltme gerekir ve üretilen promptu test etmeden üretime alma.</p><h3>6. Agentic: Araç kullanan çok adımlı akışlar</h3><p><strong>ReAct (5 · 4 · 4).</strong> Model her turda ne yapacağını düşünür, bir araç çağırır, sonucu gözlemler ve döngüye devam eder. Araç kullanan ajan sistemlerinin temel çerçevesi. Gözlem adımını modele uydurtma, gerçek araç çıktısı beslenmeli. Araç yoksa döngü teatral bir taklide dönüşür ve tur sınırı koymazsan model aynı aramada döngüye girebilir.</p><p><strong>Plan-and-Execute (4 · 3 · 3).</strong> Model önce baştan sona bir plan yazar, plan onaylandıktan sonra adımları uygular. Çok adımlı, maliyetli veya geri alınamaz işlemlerde ve insan onayı gereken otomasyonlarda yön kaybını azaltır. Belirsizliğin çok yüksek olduğu keşif görevlerinde katı plan engel olur, orada ReAct daha uygun.</p><p><strong>Reflexion (4 · 4 · 4).</strong> Başarısız denemeden sonra model neyin yanlış gittiğini yazılı bir derse dönüştürür ve bu dersi bir sonraki denemenin başına ekler. Kod yazıp test çalıştıran ve düzelten ajan döngüleri için ideal. Dersler somut olmalı: “daha dikkatli olacağım” bir kural değildir. Ders listesini en fazla 5–7 madde tut.</p><p><strong>Araç Tanımı Tasarımı (5 · 3 · 1).</strong> Ajan performansının büyük kısmı araç açıklamalarının kalitesinde saklıdır. Aracın ne zaman kullanılacağını, ne döndüreceğini ve <strong>ne zaman kullanılmayacağını</strong> yaz. Kaynağa göre aşırı araç çağrısının ana nedeni “ne zaman kullanma” bölümünün atlanmasıdır. Hata durumunda modelin ne yapacağını da yaz ve onlarca benzer araç tanımlamak yerine araçları birleştir.</p><p><strong>Çoklu Ajan Orkestrasyonu (4 · 5 · 5).</strong> Görevi dar sorumluluklu ajanlara dağıtırsın, bir orkestratör sonuçları birleştirir. Uzmanlaşma kaliteyi artırır ama karmaşıklık ve maliyet de artar. Ajanlar arası şema tanımlanmadan kurulan sistemler hızla bozulur. Sorumlulukları örtüştürme, çelişki çözüm kuralını tanımla ve her ajana tüm bağlamı verme. Tek ajanın çözebildiği işte bunu kullanma.</p><h3>Teknikleri birleştirmek: 5 hazır tarif</h3><p>Teknikler bağımsız da, birlikte de kullanılır. Sık karşılaşılan işler için kaynaktaki beş yığın şöyle:</p><ul><li><strong>Belgeden güvenilir cevap:</strong> uzun bağlam yerleşimi + kaynağa sadakat + chain-of-verification + metacognitive. Uydurma riski düşük, alıntılı cevap için.</li><li><strong>Karmaşık karar analizi:</strong> role + step-back + çoklu persona + metacognitive. Ödünleşimli bir kararı farklı açılardan sınamak için.</li><li><strong>Veri çıkarımı ve otomasyon:</strong> talimat-bağlam-format + few-shot + yapılandırılmış çıktı + negative. Serbest metinden sisteme girecek veri çıkarmak için.</li><li><strong>Sayısal problem çözme:</strong> chain-of-thought + program-of-thought + self-consistency. Hesabı denetlenebilir biçimde çözmek için.</li><li><strong>Metin taslağı ve düzeltme:</strong> role + contrastive + self-refine + negative. Metni ölçütlere göre üretip kendi kendine iyileştirmek için.</li></ul><p>Bir tarifin nasıl göründüğüne örnek, üç tekniğin (rol, yapı, doğrulama) tek promptta birleşmesi:</p><pre>&lt;rol&gt; Kıdemli veri analisti &lt;/rol&gt;<br>&lt;görev&gt; Satış düşüşünü açıkla &lt;/görev&gt;<br>&lt;yöntem&gt;<br>  1. Adım adım düşün, sonra cevapla.<br>  2. Her iddiayı veriden alıntıla.<br>  3. Sonunda güven puanı ver.<br>&lt;/yöntem&gt;<br>&lt;format&gt; JSON · 3 bulgu &lt;/format&gt;</pre><h3>En sık yapılan 6 hata</h3><p>Teknik bilmek kadar, alışkanlığı düzeltmek de önemli. Kaynaktaki altı tuzak ve düzeltmeleri:</p><ol><li><strong>Kibar ama boş talimat.</strong> “Bu raporu biraz daha iyi hale getirir misin?” yerine: “Her paragrafı en fazla 3 cümleye indir, pasif çatıyı aktife çevir, sayıları tabloya taşı.”</li><li><strong>Talimat ile verinin karışması.</strong> Kullanıcı metnini talimatın ortasına yapıştırmak yerine veriyi &lt;veri&gt; etiketleri arasına al, talimatı dışarıda tut.</li><li><strong>Bilinmeyen için çıkış yolu bırakmamak.</strong> “Bu ürünün 2027 satış rakamını yaz” yerine: “Veri yoksa ‘veri yok’ yaz, tahmin yürütme.”</li><li><strong>Örneklerin hepsinin tek tip olması.</strong> 5 örneğin hepsi olumlu sınıftan olmasın. Her sınıftan en az bir örnek ve bir uç durum ekle.</li><li><strong>Tek promptta her şeyi istemek.</strong> “Araştır, analiz et, yaz, düzelt” hepsini tek istekte istemek yerine zincir kur.</li><li><strong>Uzunluğu sıfatla belirtmek.</strong> “Kısa ve öz bir özet” yerine: “En fazla 80 kelime, 3 madde.”</li></ol><p>Hepsinin ortak noktası aynı: modelin tahmin etmesi gereken bir boşluk bırakmak. İyi prompt, bu boşlukları kapatır.</p><h3>Nereden başlamalı?</h3><p>34 tekniği aynı anda uygulamaya çalışmak yerine kademeli ilerlemek daha mantıklı:</p><ol><li><strong>Önce iskeleti kur:</strong> talimat + bağlam + format. Gerekiyorsa role ve few-shot ekle.</li><li><strong>Biçim sorunuysa:</strong> XML ile ayır, yapılandırılmış çıktı iste, API kullanıyorsan prefill dene.</li><li><strong>Akıl yürütme gerekiyorsa:</strong> chain-of-thought ile başla. Sayısal işlerde program-of-thought ve self-consistency ekle.</li><li><strong>Doğruluk kritikse:</strong> kaynağa sadakat, chain-of-verification ve metacognitive ile kontrol katmanı kur.</li><li><strong>İş tek promptta güvenilir yapılamıyorsa:</strong> zincirle ya da plana böl.</li><li><strong>Ajan kuracaksan:</strong> önce araç tanımlarına yatırım yap, çünkü ajan hatalarının çoğu araç tarifinden gelir.</li></ol><p>Maliyet puanlarına da göz at: tree of thoughts, self-consistency ve çoklu ajan gibi pahalı yöntemleri, ucuz yöntemlerin yetmediğini gördükten sonra devreye al.</p><h3>Kapanış</h3><p>Prompt mühendisliği, modele sihirli kelimeler söylemek değil. Belirsizliği azaltmak, düşünme yolunu şekillendirmek ve sonucu sınamak. Her tekniğin ne zaman işe yaradığını olduğu kadar ne zaman yaramadığını da bilmek, kütüphanene teknik eklemekten daha değerli.</p><p>Derinlemesine okumak istersen Anthropic’in prompt mühendisliği dokümantasyonu iyi bir başlangıç: <a href="https://docs.claude.com/en/docs/build-with-claude/prompt-engineering/overview">Anthropic Prompt Engineering</a>.</p><p>Hangi teknikleri birlikte kullanıyorsun ya da hangisi sana en çok fayda sağladı? Yorumlarda paylaşırsan merak ederim.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fabf1a4730e0" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>