<?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 Özge on Medium]]></title>
        <description><![CDATA[Stories by Özge on Medium]]></description>
        <link>https://medium.com/@baskinozge24?source=rss-789917af4e61------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*tJKtJJBOoUNnrlIel1LGoA.jpeg</url>
            <title>Stories by Özge on Medium</title>
            <link>https://medium.com/@baskinozge24?source=rss-789917af4e61------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 17:27:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@baskinozge24/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[AGENTIC AI (YAPAY ZEKA AJANLARI): BİR MODEL NASIL DÜŞÜNMEKTEN EYLEME GEÇER?]]></title>
            <link>https://medium.com/@baskinozge24/agentic-ai-yapay-zeka-ajanlari-bi%CC%87r-model-nasil-d%C3%BC%C5%9F%C3%BCnmekten-eyleme-ge%C3%A7er-000073605cff?source=rss-789917af4e61------2</link>
            <guid isPermaLink="false">https://medium.com/p/000073605cff</guid>
            <category><![CDATA[nlp]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Özge]]></dc:creator>
            <pubDate>Sat, 14 Nov 2026 11:43:59 GMT</pubDate>
            <atom:updated>2026-11-14T11:43:59.609Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wcJVX5VbA0P6P816pkldmQ.png" /></figure><blockquote>Bir yapay zekaya bir işi anlatmakla o işi gerçekten yapmasını istemek arasında bir fark var mı? E tabii ki…</blockquote><p>İnternetten satın aldığımız bir ürünü iade edeceğimizi düşünelim. Müşteri hizmetlerine yazıyoruz ve karşımızdaki sistem de bize iade koşullarını açıklayıp gerekli adımları sıralıyor. Peki ya biraz daha fazlasını yapabilseydi?</p><p>Siparişimizi bulsa, iade koşullarını kontrol etse, uygun iade yöntemini belirlese ve bizim onayımızla iade talebini oluştursa?</p><p>İlk durumda sorularımızı yanıtlayan bir sistem var. İkinci durumda ise bir hedef doğrultusunda farklı işlemleri gerçekleştirebilen bir yapay zeka sistemi karşımıza çıkıyor. AI Agent kavramı da işte tam olarak bu değişimi anlatıyor.</p><h4>Yapay Zeka Ajanını Chatbot’tan Ayıran Ne?</h4><p>Kullandığımız dil modelleri metin oluşturabiliyor, sorularımızı yanıtlayabiliyor, kod yazabiliyor ve karmaşık konuları açıklayabiliyor. Ama bir soruya doğru cevabı vermekle bir görevi tamamlamak aynı şey değil.</p><p>Bir chatbot’a “Bu kod neden hata veriyor?” diye sorduğumuzda olası hata nedenlerini açıklayabilir. Bir ai agent’a aynı görevi verdiğimizde ise sistem kod dosyalarını inceleyebilir, testleri çalıştırabilir, hata mesajlarını değerlendirebilir ve uygun bir düzeltme önerebilir.</p><p>Buradaki önemli fark, modelin yalnızca bir cevap üretmesi değil hedefe ulaşmak için farklı araçları kullanarak süreci yönetebilmesidir.</p><p><strong>AI Agent</strong>, bir dil modelinin belirli talimatlar ve güvenlik sınırları içerisinde araç kullanarak görevleri gerçekleştirebildiği sistemlere verilen isimdir. Elebtte her chatbot bir ajan değildir. Bir modele yalnızca API üzerinden erişim sağlamak da onu otomatik olarak bir AI Agent haline getirmez. Önemli olan modelin görevin nasıl ilerleyeceğine ilişkin karar sürecini yönetebilmesidir.</p><h4>Bir Ajanın İşe Başlaması İçin Neye İhtiyacı Var?</h4><p>Bir AI Agent geliştirdiğimizi düşünelim. Kullanıcıdan gelen isteği anlayabilmesi, gerekli işlemleri gerçekleştirebilmesi ve elde ettiği sonuçlara göre devam edebilmesi gerekiyor. Bunun için bazı bileşenleri incelememiz gerekiyor.</p><ol><li><strong>Model: Karar Mekanizması</strong></li></ol><p>Sistemin merkezinde genellikle bir LLm bulunur. Model, kullanıcının isteğini yorumlar ve hangi işlemlerin gerekli olduğunu belirler. Ama modelin her şeyi tek başına yapmasını bekleyemeyiz. Örneğin bir siparişin gerçekten gönderilip gönderilmediğini öğrenmek için ilgili sisteme erişmesi gerekir.</p><p><strong>2. Tools: Modelin Kullanabildiği Araçlar</strong></p><p>Ajanların en önemli özelliklerinde biri dış sistemlerle etkileşim kurabilmeleridir. Bunun için tools (araçlar) kullanılır. Bir araç, modelin belirli bir işlemi gerçekleştirmek üzere çağırabileceği bir fonksiyon veya API olabilir. Örneğin:</p><ul><li>Sipariş bilgilerini sorgulamak.</li><li>Bir veri tabanından kayıt getirmek.</li><li>Web üzerinde arama yapmak.</li><li>Bir dosyanın içeriğini okumak.</li><li>Bir e-posta taslağı oluşturmak.</li></ul><p>Burada dikkat etmemiz gereken bir detay var: Model bir aracı kullanmaya karar verebilir ama gerçek işlemi ilgili fonksiyon veya API gerçekleştirir. Yani modelin araç kullanması arka planda yazılım bileşenlerinin çalışmasını gerektirir.</p><p><strong>3. Memory: Önceki Bilgileri Hatırlamak</strong></p><p>Bir görev birkaç aşamadan oluşuyorsa sistemin önceki adımlarda elde ettiği bilgileri koruması gerekir. Mesela bir yazılım hatasını araştıran ajan, ilk test sonucunu ve daha sonra yaptığı değişiklikleri takip etmelidir.</p><p>Burada bellek, görev sırasında oluşan bağlamın korunmasına yardımcı olur. Ama her AI Agent’ın kalıcı bir belleğe sahip olması gerekmez. Belleğin nasıl tutulacağı geliştirilen sistemin ihtiyacına bağlıdır.</p><p><strong>4. Planning: Sonraki Adımı Belirlemek</strong></p><p>Bir görevi tamamlamak için tek bir işlem yeterli olmayabilir. Bir yazılım projesindeki hatayı araştırmak isteyen bir ajan şu adımları izleyebilir:</p><ul><li>Önce hata mesajını inceler.</li><li>İlgili kod bölümünü bulur.</li><li>Gerekirse testleri çalıştırır.</li><li>Elde ettiği sonuçları değerlendirir.</li><li>Bir düzeltme önerir ve tekrar test yapar.</li></ul><p>Bütün adımların baştan kesin olarak belirlenmesi gerekmez. Ajan, önceki işlemlerden elde ettiği sonuçlara göre sonraki adımını değiştirebilir.</p><h4>Asıl Mesele Her Şeyi Önceden Planlamak Zorunda Olmamak</h4><p>AI Agent yaklaşımını ilginç kılan noktalardan biri de bu sanırım. Geleneksel yazılım otomasyonlarına baktığımızda hangi koşulda hangi işlemin yapılacağını önceden tanımladığımızı görürüz. Mesela, bir kullanıcı formu gönderirse → verileri kontrol et → uygunsa kaydet → sonucu göster.</p><p>Bu oldukça kullanışlı tabii. Çünkü süreç belli ve her adım geliştirici tarafından belirlendi. Ama bazı problemler bu kadar öngörülebilir olmayabilir.</p><p>Bir kullanıcının yazılım projesindeki hatanın nedenini bulmasını istediğini düşünelim. Hatanın kaynağı veri tabanı, API, yanlış yapılandırma veya kod içerisindeki bir işlem olabilir. Hangi adımların gerekli olduğunu en baştan kesin olarak belirlemek kolay değildir.</p><p>AI Agent yaklaşımında model, elde ettiği sonuçlara göre hangi aracı kullanacağına ve nasıl ilerleyeceğine karar verebilir. Anthropic’in <em>Building Effective Agents</em> çalışmasında bu ayrım özellikle ele alınıyor. Önceden belirlenmiş işlem yollarıyla ilerleyen workflow sistemleri ve modelin kendi işlem sürecini yönlendirdiği agent sistemleri birbirinden ayrılıyor. Bu da önemli bir mühendislik kararını beraberinde getiriyor: Her problem için otonom bir ajan geliştirmek zorunda değiliz. Adımları belli bir işte klasik otomasyon çok daha mantıklı olabilir.</p><h4>Birden Fazla Ajan Birlikte Çalışırsa?</h4><p>Tek bir ajanın her işi yapmasını beklemek yerine görevleri farklı ajanlara dağıtabilir. Bu yaklaşım <strong>Multi-Agent Systems</strong> olarak adlandırılır. Bir yazılım geliştirme süreci düşünelim:</p><ul><li>Bir ajan gereksinimleri analiz edebilir.</li><li>Başka bir ajan kod üzerinde çalışabilir.</li><li>Bir test ajanı oluşturulan kodu kontrol edebilir.</li><li>Sonuçları değerlendiren başka bir ajan rapor hazırlayabilir.</li></ul><p>Böyle bir mimaride ajanlar birbirlerine görev aktarabilir veya belirli bir koordinasyon mekanizması üzerinden çalışabilir. Ama tabii ki de daha fazla ajan kullanmak otomatik olarak daha başarılı bir sistem oluşturmaz. Ajanlar arasındaki iletişim, tekrar eden işlemler, maliyet ve hata ihtimalleri de artabilir. Bazen tek bir iyi tasarlanmış ajan, birden fazla ajanın birlikte çalışmasından çok daha verimli olabilir.</p><h4>Peki Bir Yapay Zekaya Ne Kadar Yetki Vermeliyiz?</h4><p>Bir ajanın sipariş durumunu sorgulamasıyla siparişi iptal etmesi aynı şey değil. Bir kod dosyasını incelemesiyle doğrudan kodu değiştirebilmesi de aynı risk düzeyinde elbette ki değerlendirilemez. Bu yüzden AI Agent sistemlerinde yalnızca modelin ne yapabildiğin değil be yapmasına izin verilmesi gerektiğini de düşünmeliyiz. Bu noktada karşımıza <strong>Guardrails </strong>adı verilen kontrol mekanizmaları çıkıyor. Örneğin:</p><ul><li>Hangi araçların kullanılabileceği sınırlandırılabilir.</li><li>Hassas işlemler için kullanıcı onayı istenebilir.</li><li>Ajanın gerçekleştirebileceği işlem sayısına sınır konulabilir.</li><li>Hata durumunda işlem durdurulabilir ve insan müdahalesi istenebilir.</li></ul><p>Özellikle ödeme, veri silme veya hesap değişikliği gibi sonuçları geri alınması zor işlemlerde insan onayı önemli bir güvenlik katmanıdır.</p><blockquote>Bir sistemin otonom olması kontrolsüz olmasını gerektirmez.</blockquote><h4>Sonuç: Daha Akıllı Sistemler mi Daha Fazla Sorumluluk mu?</h4><p>Yapay zeka alanında yaşanan gelişmelerle birlikte modellerden beklentilerimiz de değişiyor. Artık sadece sorularımızı yanıtlayan sistemler değil farklı araçları kullanabilen, görevler parçalara ayırabilen ve elde ettikleri sonuçlara göre yeni adımlar belirleyebilen uygulamalar geliştiriyoruz. AI Agent da bu dönüşümün önemli parçalarından biri. Ama üstünde durmamız gereken konu bu sistemlerin ne kadar fazla işlem yapabildiğinden ziyade yaptıkları işlemleri ne kadar güvenilir biçimde gerçekleştirebildikleri. Çünkü bir yapay zekanın yanlış bir cevap vermesiyle yanlış bir işlemi gerçekleştirmesi arasında önemli bir fark var.</p><blockquote>Kendimize zor güveniyoruz ai’ya nasıl güveneceğiz?</blockquote><p>“Yapay zeka bunu yapabilir mi?” diye sormaya artık gerek yok. Belli ki yapabilir. Asıl sormamız gereken soru artık <strong>“Yapay zekaya bunu yapma yetkisini vermek ne kadar doğru?”</strong></p><h4>Kaynakça</h4><ol><li><strong>Anthropic (2024).</strong> <a href="https://www.anthropic.com/research/building-effective-agents?utm_source=chatgpt.com">Building Effective Agents</a> — Workflow ve agent ayrımı, araç kullanımı ve otonom sistemler.</li><li><strong>OpenAI (2026).</strong> <a href="https://openai.com/business/guides-and-resources/a-practical-guide-to-building-ai-agents/?utm_source=chatgpt.com">A Practical Guide to Building AI Agents</a> — Model, araçlar, talimatlar, orkestrasyon ve güvenlik.</li><li><strong>Yehudai et al. (2026).</strong> <a href="https://aclanthology.org/2026.findings-acl.1330/?utm_source=chatgpt.com">A Survey on Evaluation of LLM-based Agents</a> — Ajanların planlama, araç kullanımı, güvenlik ve maliyet açısından değerlendirilmesi.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=000073605cff" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[YAPAY ZEKA HER ŞEYİ BİLMEK ZORUNDA MI? RAG İLE BİLGİYE ERİŞMEK- NLP 2]]></title>
            <link>https://medium.com/@baskinozge24/yapay-zeka-her-%C5%9Feyi%CC%87-bi%CC%87lmek-zorunda-mi-rag-i%CC%87le-bi%CC%87lgi%CC%87ye-eri%CC%87%C5%9Fmek-nlp-2-b836eb973e56?source=rss-789917af4e61------2</link>
            <guid isPermaLink="false">https://medium.com/p/b836eb973e56</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[rags]]></category>
            <category><![CDATA[nlp]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Özge]]></dc:creator>
            <pubDate>Fri, 13 Nov 2026 14:24:22 GMT</pubDate>
            <atom:updated>2026-11-13T14:24:22.417Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8DkNxn1dL8b0PnDYYXtxUA.png" /></figure><blockquote>Bir yapay zekâ modelinin eğitiminde yer almayan bilgilere erişmesini sağlayabilir miyiz?</blockquote><p>Aylardır açık duran iş ilanları, sonsuza kadar süren milyon aşamalı mülakatlar, başarısızlık ve yetersizlik hisleri, dönüş alınamayan mail’ler, çevrenizdeki insanların “sen bir hiçsin” bakışları ve reddedilmeye bile değer bulunmayan başvurulardan sonra sonunda bir şirkette çalışmaya başladığınızı düşünün. Şirketin teknik dokümantasyonu, ürün kılavuzları, kullanım prosedürleri ve sürekli güncellenen belgeleri olsun. Bir gün yapay zeka asistanına şu soru soruluyor:</p><p>“Geçen ay güncellenen izin prosedürüne göre yıllık izin talebimi nasıl oluşturabilirim?”</p><p>Ben olsam şöyle cevap verirdim: “Gerçekten ölüm kalım meselesi olduğuna, maaş gibi maddi; anlayış gibi manevi şeyler beklemeyeceğine ve izin aldığın için yapılan mobbinglere ses çıkarmayacağına inandığın bütün değerler üzerine yemin edip talebini oluşturabilirsin.”</p><p>Tabii burada bana sorulmadığı için modelimizin verdiği oldukça düzgün cevapla devam ediyoruz. Ama verdiği cevabın eski bir prosedüre dayandığını hatta belki de hiç var olmayan bir kuraldan bahsettiğini fark ediyoruz. Buradaki sorun modelin dil yetneeğinin yetersiz olması değil güncel bilgiye erişememesi. Büyük dil modellerinin (LLM) önemli sınırlılıklarından biri tam olarak bu noktada ortaya çıkıyor. Eğitim sırasında öğrendikleri bilgiler her zaman güncel olmayabilir.</p><p>Peki her yeni bilgi için modeli yeniden eğitmek zorunda mıyız?</p><p>Aslında hayır. Bunun için kullanılan yaklaşımlardan biri <strong>Retrieval-Augmented Generation (RAG)</strong>.</p><h4><strong>Modelin Bilgisi ile Dış Dünyadaki Bilgi Aynı Şey Değil</strong></h4><p>LLM, eğitim süreçlerinde çok büyük miktarda metinden dilsel örüntüler öğrenir. Bu bilgiler modelin parametrelerinde temsil edilir. Ancak modelin parametrelerinde bulunan bilgiler ile dış dünyada sürekli değişen bilgiler aynı şey değildir.</p><p>Örneğin bir ürünün kullanım kılavuzu güncellendiğinde, modelin bu değişikliği kendiliğinden öğrenmesini bekleyemeyiz. Benzer şekilde, bir şirketin yalnızca çalışanlarına açık olan belgelerinin de model tarafından önceden biliniyor olması mümkün değildir.</p><p>Bu tür durumlarda iki farklı yaklaşım düşünülebilir:</p><ul><li>Modeli yeni verilerle yeniden eğitmek veya fine-tuning uygulamak.</li><li>Model yanıt üretmeden önce ihtiyaç duyduğu bilgiyi harici bir kaynaktan getirmek.</li></ul><p>İkinci bahsettiğimiz yaklaşım RAG’ın temelini oluşturur.</p><p><strong>RAG, dil modelinin kendi öğrendiği bilgilerin yanı sıra, yanıt üretmeden önce dış kaynaklardan ilgili bilgileri getirmesini sağlayan bir mimari yaklaşımdır.</strong></p><p>Burada önemli olan, modele yeni bilgileri kalıcı olarak öğretmek değil ihtiyaç duyduğu anda doğru bilgiye erişmesini sağlamaktır.</p><h4><strong>RAG Nasıl Çalışıyor?</strong></h4><p>Bir RAG sistemini anlamak için onu üç temel aşamada düşünebiliriz:</p><ol><li>Bilginin hazırlanması ve aranabilir hâle getirilmesi.</li><li>Kullanıcının sorusuna uygun bilginin bulunması.</li><li>Bulunan bilgilerin kullanılarak yanıt oluşturulması.</li></ol><p>İlk aşama genellikle sistem kurulurken gerçekleştirilir. Sonraki iki aşama ise kullanıcı bir soru sorduğunda devreye girer.</p><ol><li><strong>Bilgiyi Hazırlamak : Chunking ve Embedding</strong></li></ol><p>Öncelikle sistemin kullanacağı belgeleri belirlememiz gerekiyor. Bunlar PDF, teknik dokümanlar, web sayfaları veya veri tabanlarında tutulan metinler olabilir. Ancak yüzlerce sayfalık bir belgeyi olduğu gibi arama sistemine aktarmak her zaman verimli değildir. Bu nedenle belgeler daha küçük parçalara ayrılır. İşte bu işleme <em>chunking </em>denir.</p><p>Ardından bu metin parçaları embedding modelleri kullanılarak sayısal vektörlere dönüştürülür. Böylece metinler yalnızca kelime eşleşmesine göre değil anlamsal benzerlikleri üzerinden de aranabilir hale gelir. Bu vektörler genellikle bir vektör veri tabanında veya vektör aramayı destekleyen başka bir veri altyapısında saklanır.</p><p><strong>2. Bilgiyi Bulmak : Retrieval</strong></p><p>Kullanıcı bir soru sorduğunda sistem bu soruya da bir embedding modelinden geçirerek vektörel bir temsile dönüştürür. Daha sonra soru vektörü ile önceden oluşturulmuş belge vektörleri karşılaştırılır. Böylece soruyla anlamsal açıdan ilişkili metin parçaları bulunur. İşte bu aşamaya da <em>retrieval </em>yani bilgi getirme denir.</p><p>Örneğin kullanıcı “Yıllık izin talebi nasıl oluşturulur?” diye sorduğunda sistem, şirketin izin prosedürünü içeren ilgil belge parçalarını bulmaya çalışır. Burada yalnzıca benzer kelimelerin bulunması yeterli değildir. Getirilen bilgilerin gerçekten soruyu yanıtlamaya yardımcı olması gerekir.</p><p><strong>3. Yanıt Oluşturmak : Generation</strong></p><p>Son aşamada ise buşunan metin parçaları kullanıcının sorusuyla birlikte dil modeline iletilir. Model, kendisine sunulan bağlamdan yararlanarak yanıt oluşturur. Böylece yanıt yalnızca modelin önceden öğrendiği bilgilere değil ilgili soruyla eşleştirilen dış kaynaklara da dayanabilir.</p><p>Kısacası RAG sisteminin yaptığı şey, doğru bilgiyi bulmak ve bu bilgiyi dil modelinin kullanabileceği bir bağlam haline getirmektir.</p><h4>Her RAG Sistemi Sadece Vektör Aramasından mı İbaret?</h4><p>RAG denildiğinde çoğu zaman akla embedding ve vektör veri tabanları geliyor. Ama bu mimariyi sadece anlamsal benzerlik araması olarak değerlendirmek biraz eksik kalabilir. Örneğin bazı sistemlerde <strong>Hybrid Search</strong> kullanılır. Bu yaklaşımda anlamsal arama ile anahtar kelime tabanlı arama birlikte değerlendirilir. Peki bu neden önemlidir?</p><p>Bir teknik dokümanda belirli bir hata kodunu aradığımızı düşünelim. “ERR-1042” gibi ibir ifadeyi bulmak için tam kelime eşleşmesi oldukça yararlı bir durumdur. Ama kullanıcının “Uygulama neden bağlantı kuramıyor?” sorusuna yanıt ararken anlamsal arama daha anlamlı sonuçlar sağlayabilir.</p><p>Bir diğer yaklaşım ise <strong>Reranking </strong>işlemidir. İlk aramada bulunan sonuçlar daha ayrıntılı bir değerlendirmeden geçirilerek soruyla en ilgili olanlar üst sıralara taşınır. Dolayısıyla gerçek bir RAG sisteminin başarısı sadece hangi dil modelini kullandığımıza bağlı olan bir şey değildir. Bilginin nasıl parçalandığı, nasıl indekslendiği, nasıl arandığı ve modele nasıl sunulduğu da oldukça önemlidir.</p><p>Bu vesileyle de hatırlatalım: bizim başarımız da sadece tek bir duruma bağlı değildir. Başarısızlık da başarı kadar doğaldır. Kendimize çok yüklenmeyelim zaten insanlar bunu fazlasıyla yapıyor. Hayatın sırrını çözmüş gibi de davrandığımıza göre devam edelim.</p><h4>RAG Halüsinasyon Problemini Tamamen Çözer mi?</h4><p>RAG’ın önemli kullanım amaçlarından biri, dil modellerinin ürettiği yanıtları dış kaynaklarla desteklemektir. Ama bu yaklaşım halüsinasyon problemini tamamen ortadan kaldırmaz. Örneğin sistem yanlış belgeyi getirebilir. Doğru belgeyi bulsa bile ilgili bölümü gözden kaçırabilir. Model ise kendisine sunulan bağlamı yanlış yorumlayabilir veya kaynakta bulunmayan bilgiler ekleyebilir.</p><blockquote>Hatasız dil modeli olmaz.</blockquote><p>Bu nedenle bir RAG sistemini değerlendirirken sadece cevabın düzgün görünmesine bakmak yeterli değildir. En az üç soruyu sormalıyız:</p><ul><li><strong>Context Relevance:</strong> Getirilen bilgiler soruyla ne kadar ilgili?</li><li><strong>Faithfulness:</strong> Modelin oluşturduğu cevap, kendisine sunulan kaynaklarla ne kadar tutarlı?</li><li><strong>Answer Relevance:</strong> Oluşturulan cevap gerçekten soruyu karşılıyor mu?</li></ul><p>Bu değerlendirmeler, RAG sisteminin yalnızca bilgi bulup bulmadığını değil bulduğu bilgiyi doğru kullanıp kullanmadığını da anlamamızı sağlar.</p><h4>Sonuç: Daha Fazla Bilgi mi Daha İyi Bilgi Erişimi mi?</h4><p>LLM’lerin gelişimi çoğu zaman daha fazla parametre daha büyük eğitim veri setleri ve daha güçlü modeller üzerinden değerlendiriliyor. Ama gerçek dünyadaki bir problemi çözmek için her zaman daha büyük bir modele ihtiyacımız olmayabilir. Bazen ihtiyaç duyduğumuz şey doğru bilginin doğru zamanda modele sunulmasıdır.</p><p>RAG yaklaşımı bu açıdan önemli bir değişim sunuyor. Modelin sahip olduğu dil yeteneğini dış kaynaklardan elde edilen güncel ve alana özgü bilgilerle bir araya getiriyor. Elbette başarılı bir sistem oluşturmak yalnızca bir dil modelini vektör veritabanına bağlamak kadar basit değil. Bilgi getirme kalitesi, veri güvenliği, kaynakların güncelliği ve yanıtların değerlendirilmesi de tasarım sürecinin bir parçası.</p><blockquote><strong>Yapay zekâ sistemleri için daha fazla bilgiye sahip olmak mı, yoksa ihtiyaç duydukları bilgiye güvenilir biçimde ulaşabilmek mi daha önemli?</strong></blockquote><p>Belki de geleceğin başarılı yapay zekâ uygulamalarını belirleyecek şey, yalnızca daha güçlü modeller geliştirmek değil, bu modellerin doğru bilgiyle nasıl çalışacağını tasarlamak olacak. (Hadi ya hiç aklınıza gelmemişti değil mi?)</p><p>Vakit ayırdığınız için teşekkür ederim. Sonraki yazıda görüşmek dileğiyle.</p><blockquote>Serinin devamında: Yapay Zekâ Ajanları — Bir dil modeli yalnızca yanıt üretmek yerine bir görevi planlayıp gerçekleştirebilir mi?</blockquote><h4>Kaynakça</h4><ol><li>Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., Goyal, N., Küttler, H., Lewis, M., Yih, W.-t., Rocktäschel, T., Riedel, S., &amp; Kiela, D. (2020). Retrieval-augmented generation for knowledge-intensive NLP tasks. <em>Advances in Neural Information Processing Systems, 33</em>. <a href="https://arxiv.org/abs/2005.11401">https://arxiv.org/abs/2005.11401</a></li><li>Es, S., James, J., Espinosa Anke, L., &amp; Schockaert, S. (2024). RAGAs: Automated evaluation of retrieval augmented generation. <em>Proceedings of the 18th Conference of the European Chapter of the Association for Computational Linguistics: System Demonstrations</em>, 150–158. <a href="https://doi.org/10.18653/v1/2024.eacl-demo.16">https://doi.org/10.18653/v1/2024.eacl-demo.16</a></li><li>Wu, S., Xiong, Y., Cui, Y., Wu, H., Chen, C., Yuan, Y., Huang, L., Liu, X., Kuo, T.-W., Guan, N., et al. (2026). Retrieval-augmented generation for natural language processing: A survey. <em>Artificial Intelligence Review, 59</em>, Article 192. <a href="https://doi.org/10.1007/s10462-026-11605-7">https://doi.org/10.1007/s10462-026-11605-7</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b836eb973e56" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[YAPAY ZEKA KARARLARINI AÇIKLAYABİLİR Mİ? (EXPLAINABLE AI)]]></title>
            <link>https://medium.com/@baskinozge24/yapay-zeka-kararlarini-a%C3%A7iklayabi%CC%87li%CC%87r-mi%CC%87-explainable-ai-e33426ead1b2?source=rss-789917af4e61------2</link>
            <guid isPermaLink="false">https://medium.com/p/e33426ead1b2</guid>
            <category><![CDATA[explainable-ai]]></category>
            <category><![CDATA[shap]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Özge]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 17:02:16 GMT</pubDate>
            <atom:updated>2026-11-04T17:02:16.200Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TM3B07KSCHJzxbP-ZIr5LA.png" /></figure><blockquote>Dünyanın bütün yapay zekaları birleşin ve ses çıkarın “Onu da mı ben yapayım!”</blockquote><p>Bir yapay zeka modeli doğru bir sınıflandırma yaptığında verdiği kararın nedenini biliyor muyuz? Öğrenelim mi?</p><p>Örneğin bir duygu analizi modeli düşünelim, bir kullanıcı yorumunu olumsuz olarak sınıflandırsın. Sonuca bakıyoruz sonuç doğru. Peki model bu karara hangi kelimelere, ifadelere veya örüntülere bakarak ulaştı? Anlamlı ipuçları mı kullandı yoksa eğitim verisindeki tesadüfi bir ilişkiyi mi öğrendi?</p><p>İşte bu sorular açıklanabilir yapay zeka (alanını gündeme getiriyor.</p><h3>Black Box: Modelin İçinde Ne Oluyor</h3><p>Makine öğrenmesi modelleri girdilerden belirli çıktılar üretir, bunu biliyoruz. Ancak özellikle karmaşık modellerde bu sonuca nasıl ulaşıldığını anlamak her zaman kolay olmuyor. Bir modele veri veririz, model bir tahmin üretir ve çoğu zaman yalnızca bu tahmini görürüz. Aradaki karar süreci ise dışarıdan bakıldığında bir kara kutu (black box) gibi kalabilir.</p><p>Buradaki sorun yalnızca modelin nasıl çalıştığını merak etmemiz değil. Bir modelin hatalı, önyargılı veya güvenilir olmayan bir karar verdiğini fark edebilmek için de bu kararın arkasındaki etkenleri anlamamız gerekir.</p><p>İşte XAI tam olarak bu noktada devreye girer.</p><h3>Explainable AI (XAI) Nedir?</h3><p>Explainable AI, yapay zekâ modellerinin ürettiği sonuçların insanlar tarafından anlaşılabilir ve yorumlanabilir hâle getirilmesini amaçlayan yöntemler bütünüdür.</p><p>Burada hedefimiz sadece modelin ne tahmin ettiğini değil bu tahmini etkileyen faktörlerin neler olduğunu da inceleyebilmek. Ama burada birbirinden ayırmamız gereken iki kavram var: <strong>Interpretability (yorumlanabilirlik) ve Explainability (açıklanabilirlik).</strong></p><ul><li><strong>Interpretability:</strong> Modelin yapısının veya karar mekanizmasının doğrudan insanlar tarafından anlaşılabilmesi.</li><li><strong>Explainability:</strong> Modelin ürettiği belirli bir tahminin hangi etkenlerle ilişkili olduğunun açıklanabilmesi.</li></ul><p>Peki bir modelin kararını nasıl açıklarız?</p><p>XAI alanında kullanılan yöntemlerden ikisi özellikle dikkat çekiyor: <strong>LIME </strong>ve <strong>SHAP</strong>.</p><ol><li>LIME: Bir Tahminin Yakın Çevresini İncelemek</li></ol><p>LIME (Local Interpretable Model-Agnostic Explanations), belirli bir tahminin nedenini anlamaya çalışan bir yöntemdir. Karmaşık modelin tamamını açıklamaya çalışmak yerine yalnızca seçriğimiz bir örnek etrafındaki davranışını inceler.</p><p>Metindeki bazı kelimeleri değiştirerek veya devre dışı bırakarak modelin tahmininin nasıl etkilendiğini gözlemler. Böylece hangi kelimelerin ilgili tahmini olumlu ya da olumsuz yöndde etkilediğine dair yerel bir açıklama oluşturur.</p><p>Burada bir şeye dikkat etmek gerekiyor: LIME, modelin gerçek iç işleyişini doğrudan ortaya çıkarmaz. Modelin belirli bir örnek çevresindeki davranışını basitleştirilmiş, yorumlanabilir bir yaklaşımla temsil etmeye çalışır.</p><p>2. SHAP: Tahmine Katkıda Bulunan Özellikler</p><p>SHAP (SHapley Additive exPlanations) ise oyun teorisindeki Shapley değerlerinden yararlanır. Bu yaklaşımdaki temel fikir ise bir tahminin oluşmasına özelliklerin ne ölçüde katkıda bulunduğunu hesaplamaktır.</p><p>SHAP, ifadelerin belirlenen katkılarını sayısal değerlerle ifade eder. Bylece tek bir tahmini inceleyebildiğimiz gibi bir veri kümesi genelinde modelin hangi özelliklerden daha fazla yararlandığını da değerlendirebiliriz.</p><p><strong>Her iki yöntem de modelin kararlarını daha anlaşılır hâle getirmeye yardımcı olur. Ancak farklı varsayımlara ve hesaplama yaklaşımlarına sahiptirler.</strong></p><h3>Açıklama Gerçeğin Kendisi Midir?</h3><p>Tabii ki de gerçek nedir ne kadarına ulaşabiliriz gibi felsefik tartışmalara girebiliriz ama şu anda başka bir konu üzerinde konuşuyoruz ve şu noktaya dikkat etmek gerekiyor: Bir modele açıklama yöntemi uyguladığımzıda mdoelin karar sürecini tamamen ortaya çıakrdığımızı düşünmemeliyiz.</p><blockquote>Her açıklama her zaman bizi gerçeğin kendisinin karşımızda olduğuna inandırmaz sonuçta değil mi?</blockquote><p>LIME ve SHAP gibi yöntemler, modelin davranışına ilişkin açıklamalar üretir. Ancak bu açıklamalar modelin gerçek içsel muhakemesinin doğrudan bir kaydı değildir. Kullanılan yöntem, örnekleme yaklaşımı, özellikler arasındaki ilişkiler ve seçilen arka plan verileri sonuçları etkileyebilir. Ayrıca, bir modelin belirli kelimelere önem verdiğini görmek bu kelimelerin tahmin üzerinde nedensel bir etkisi olduğunu tek başına kanıtlamaz. Bu nedenle XAI yöntemlerini yalnızca görsel olarak etkileyici açıklamalar üretmek için değil modelin güvenilirliğini sorgulamak ve farklı analizlerle sonuçları değerlendirmek için kullanmalıyız.</p><h3>Sonuç: Doğru Tahmin Yeterli Mi?</h3><p>Yapay zekâ modellerini değerlendirirken çoğunlukla doğruluk, precision, recall ve F1-score gibi metriklere odaklanıyoruz. Bunlar model performansını ölçmek için önemli. Ancak özellikle gerçek dünyada kullanılan sistemlerde, yalnızca doğru tahminler üretmek yeterli olmayabilir. Modelin hangi özelliklere dayandığını, hangi örneklerde yanıldığını ve kararlarının ne kadar tutarlı olduğunu da anlamamız gerekir.</p><p>Explainable AI, bu ihtiyaca cevap arayan önemli bir araştırma alanı. Bize yalnızca modelin sonucuna bakmak yerine, bu sonucun arkasındaki ilişkileri sorgulama imkânı sunuyor.</p><p>Gözlerimi kısıp daha sessiz bir tonda dünyanın sırrını çözmüş gibi konuşarak havalı bir şekilde bitirdiğimi düşünün şimdi:</p><blockquote>Belki de yapay zekâ sistemleri için sormamız gereken soru artık yalnızca şu değil:</blockquote><blockquote><strong>“Model doğru tahmin yaptı mı?”</strong></blockquote><blockquote>Asıl soru şu olabilir:</blockquote><blockquote><strong>“Bu tahmine neden ulaştı ve bu açıklamaya ne kadar güvenebiliriz?”</strong></blockquote><p>Bir sonraki yazıda görüşürüz umarım.</p><p><strong>Kaynakça ve ileri okuma</strong></p><ul><li>Ribeiro, M. T., Singh, S., &amp; Guestrin, C. (2016). <em>“Why Should I Trust You?”: Explaining the Predictions of Any Classifier.</em> Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 1135–1144. <a href="https://doi.org/10.1145/2939672.2939778">https://doi.org/10.1145/2939672.2939778</a></li><li>Lundberg, S. M., &amp; Lee, S. I. (2017). <em>A Unified Approach to Interpreting Model Predictions.</em> Advances in Neural Information Processing Systems, 30, 4765–4774.</li><li>Molnar, C. (2025). <em>Interpretable Machine Learning: A Guide for Making Black Box Models Explainable</em> (3rd ed.). <a href="https://christophm.github.io/interpretable-ml-book/">https://christophm.github.io/interpretable-ml-book/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e33426ead1b2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Yapay Zekâ Bizi Gerçekten Anlıyor mu? BERT ve Transformer’ın Perde Arkası-NLP 1]]></title>
            <link>https://medium.com/@baskinozge24/yapay-zek%C3%A2-bizi-ger%C3%A7ekten-anl%C4%B1yor-mu-bert-ve-transformer%C4%B1n-perde-arkas%C4%B1-nlp-1-3c3de3cd1acc?source=rss-789917af4e61------2</link>
            <guid isPermaLink="false">https://medium.com/p/3c3de3cd1acc</guid>
            <category><![CDATA[bert]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[transformers]]></category>
            <category><![CDATA[nlp]]></category>
            <category><![CDATA[berturk]]></category>
            <dc:creator><![CDATA[Özge]]></dc:creator>
            <pubDate>Mon, 26 Oct 2026 11:55:53 GMT</pubDate>
            <atom:updated>2026-10-26T11:55:53.686Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2NEMnZyQGEDAFb3Uugn1RQ.png" /></figure><p>Bir bilgisayar kelimeler arasındaki ilişkiyi nasıl kuruyor? BERT, Transformer ve Attention mekanizması hakkında biraz konuşalım o zaman.</p><p><strong>Bir yapay zeka modeli, yazdığımız cümleleri gerçekten anlıyor mu yoksa sadece anlamış gibi görünmeyi mi öğreniyor?</strong> Eğer anlamış gibi görünmeyi öğreniyorsa bunu bizden daha iyi yaptığı ortada. Bir sohbet esnasında karşımızdaki kişinin söylediğini anlamayıp gülüp geçtiğimiz anları düşünelim. Biz çok da öğrenememiş gibiyiz sanki. Gülüşümüz her şeyi ele veriyor.</p><p>Sorumuza geri dönersek eğer biliyorsunuz ki dil modellerinin kullanımı günlük hayatımızın çok büyük bir parçası haline geldi. Tabii işi abartıp yürürken sağ adımını mı yoksa sol adımını mı atması gerektiğiyle alakalı bile dil modelleriyle konuşacak çok fazla insan var ama bundan şikayet etmeyi başka bir yazıya bırakıyorum. Hayır yapay zekanın işimi elimden almasından korktuğum için söylemiyorum bunu. Birincisi ben zaten işsizim ikincisi ben kimseye hangi adımını kullanması gerektiği konusunda direktif vermiyorum. Bu yüzden istese de işimi elimden alamaz.</p><p>Hepimizin bildiği gibi bugün bir dil modeline uzun bir metin vereibliyoruz. Metni özetleyebiliyor, sorularımızı yanıtlayabiliyor hatta bazen biim fark etmediğimiz ilişkileri yakalayabiliyor. Bilmediğimiz arka tarafında tam olarak neler olduğu.</p><p>Mesela yapay zeka kullanamadığımız bir an için şu cümleyi kuruyoruz:</p><blockquote>“Harika, yine bütün işler bana kaldı.”</blockquote><p>Buradaki “harika” kelimesini tek başına ele alsak olumlu bir ifade olduğunu söyleriz. Ama cümlenin tamamını okuyunca tabii ki de mutlu değiliz. Ne demek yapay zeka benim yerime tüm işleri yapmayacak?!</p><p>Biz bunu ayırt edebildik ama bilgisayar nasıl ayırt ediyor?</p><p>Bir kelimenin olumlu ya da olumsuz olduğunu ezberlemek başka o kelimenin bulunduğu cümlede nasıl bir anlam kazandığını değerlendirmek başka. BERT ve Transformer modellerinin ilginç tarafı da tam burada başlıyor.</p><p>Bugün Transformer modellerini konuşuyoruz ama bilgisayarların metinleri işlemesi yeni bir mesele değil. Uzun yıllardır araştırmacılar bilgisayarlara insan dilini işletebilmenin yollarını arıyor. İlk akla gelen yöntemlerden biri oldukça basit: Kelimeleri saymak.</p><p>Diyelim ki elimizde yüzlerce film yorumu var ve bu yorumların olumlu mu olumsuz mu olduğunu tahmin etmek istiyoruz. Bir yorumda “mükemmel”, “güzel”, “başarılı” gibi kelimeler sık geçiyorsa olumlu; “berbat”, “sıkıcı”, “kötü” gibi kelimeler geçiyorsa olumsuz olabileceğini düşünebiliriz.Bag of Words (BoW) yaklaşımı, metinleri kelime sıklıklarına dayalı sayısal özelliklerle temsil etmenin klasik yollarından biri.Ama burada bir sorun var. Şu iki cümleye bakalım:</p><ul><li>“Bu filmi beğendim.”</li><li>“Bu filmi beğenmedim.”</li></ul><p>İki cümle birbirine oldukça benziyor ancak anlamları farklı. Kelimelerin varlığına veya sıklığına odaklanan basit bir yaklaşım, bu farkı her zaman yeterince iyi temsil edemeyebilir.</p><p>TF-IDF gibi yöntemlerle hangi kelimelerin ayırt edici olduğunu daha iyi hesaplayabiliyoruz. N-gram kullanarak kelime dizilişlerine ilişkin bazı bilgileri de ekleyebiliyoruz. Yine de dilin bütün karmaşıklığını yalnızca kelime sayılarıyla açıklamak zor. Çünkü dilde önemli olan sadece <em>hangi kelimelerin kullanıldığı</em> değil, <strong>bu kelimelerin birbirleriyle nasıl ilişki kurduğu</strong>.</p><p>Bilgisayarlar bizim gibi kelimeleri okuyup anlamlandırmıyor. Bir makine öğrenmesi modelinin metin üzerinde işlem yapabilmesi için önce metni sayısal biçimde temsil etmemiz gerekiyor. Burada karşımıza iki kavram çıkıyor: <strong>Tokenization</strong> ve <strong>Embedding</strong>.</p><p><strong>Tokenization</strong>, metni modelin işleyebileceği parçalara ayırma işlemi. Mesela “Bugün gerçekten çok yoruldum.” cümlesinde bir tokenizer bu cümleyi kelimelere, kelime parçalarına veya kullanılan yönteme bağlı olarak başka token birimlerine ayırabilir. BERT ailesindeki modellerde genellikle WordPiece adı verilen alt kelime tokenizasyonu kullanılır. Peki bu neden önemlidir? Türkçe gibi eklemeli dillerde aynı kelimenin pek çok farklı biçimiyle karşılaşabiliyoruz: gel, geldim, gelemedim, gelemeyecekmiş…</p><p>Bütün bu biçimleri birbirinden tamamen bağımsız kelimeler olarak ele almak yerine bazılarını ortak alt parçalara ayırabilmek modelin kelime dağarcığını daha verimli kullanmasını sağlayabilir.</p><p>Tokenizastion işleminden sonra token’lar sayısal kimliklere yani token ID’lerine dönüştürülür. Ama burada bir ayrım var. <strong>Bir token’a 1254 numarasını vermek onun anlamını 1254 sayısıyla ifade ettiğimiz anlaına gelmiyor.</strong> Bu numara yalnızca modelin sözlüğündeki bir kimliktir. Asıl öğrenilebilir sayısal temsiller embedding katmanında ortaya çıkar.</p><p><strong>Embedding</strong>, token’ları çok boyutlu vektörlerle temsil eder. Modelin eğitimi sırasında bu temsiller, dildeki örüntüleri yakalamaya yardımcı olacak şekilde öğrenilir. Ancak bu da tek başına bütün meseleyi çözmüyor. Çünkü bir kelimenin anlamı, bulunduğu cümleye göre değişebiliyor.</p><p>Peki model aynı kelimenin farklı anlamlarını nasıl ayıracak?</p><p>Mikolov ve arkadaşlarının (2013) çalışmalarıyla yaygınlaşan Word2Vec yaklaşımı, kelimelerin dağılımsal ilişkilerini vektör uzayında temsil edebilmemizi sağladı. Ancak bu tür statik embedding yöntemlerinde aynı kelime, farklı bağlamlarda genellikle aynı vektörle temsil ediliyordu.</p><p>Word2Vec gibi klasik statik kelime embedding yöntemlerinde, bir kelime genellikle bağlamdan bağımsız tek bir vektörle temsil edilir. Bu yöntemler önemli bir gelişmeydi. Benzer bağlamlarda kullanılan kelimelerin vektör uzayında birbirine yakın konumlanabildiğini gösterdiler. Fakat aynı kelimenin farklı cümlelerde farklı anlamlara gelmesi hâlâ önemli bir zorluktu. BERT gibi bağlamsal dil modellerinde ise durum farklı. Model, bir token’ın temsilini oluştururken çevresindeki diğer token’lardan da yararlanıyor. Yani aynı kelime, farklı cümlelerde farklı bağlamsal vektörlerle temsil edilebiliyor. Bence burada asıl önemli değişim şu:</p><p><strong>Model yalnızca kelimeler hakkında bilgi öğrenmiyor; kelimelerin birbirleriyle kurduğu ilişkilerden de yararlanıyor.</strong></p><p>Peki bunu nasıl yapıyor?</p><p>İşte <strong>Transformer</strong>’a geldik.</p><p>2017 yılında Vaswani ve arkadaşları tarafından yayımlanan Attention Is All You Need makalesi, Transformer mimarisini tanıttı. Bu mimari, tekrarlayan sinir ağlarına dayanmadan attention mekanizmalarıyla diziler arasındaki ilişkileri modelleyebiliyordu.</p><p>Transformer mimarisi, 2017 yılında yayımlanan<em> </em><a href="https://arxiv.org/abs/1706.03762?utm_source=chatgpt.com"><em>Attention Is All You Need</em></a> makalesi ile tanıtıldı. O dönemde doğal dil işleme alanında RNN ve LSTM gibi sıralı işlemeye dayalı modeller yaygın biçimde kullanılıyordu. Bu modellerin güçlü yönleri vardı. Ancak özellikle uzun dizilerde uzak konumlar arasındaki ilişkileri öğrenmek ve sıralı hesaplamalar nedeniyle eğitimi paralelleştirmek zor olabiliyordu.</p><p>Transformer farklı bir yaklaşım sundu.</p><p>Tekrarlayan ağ katmanlarına dayanmak yerine, token’lar arasındaki ilişkileri attention mekanizması üzerinde modellemeyi merkeze aldı.</p><p>Peki attention ne demek?</p><p>Bir cümleyi okurken her kelimeyi dğer bütün kelimelerden tamamen bağımsız değerlendirmiyoruz. Mesela:</p><blockquote>“Ayşe, Zeynep’e kitabını verdi çünkü o sınava hazırlanıyordu.”</blockquote><p>Buradaki “o” zamiri kimi anlatıyor?</p><p>Muhtemelen Zeynep’i düşündünüz ancak bunu kesinleştirmek için daha fazla bağlam gerekebilir.</p><p>Vaswani ve arkadaşlarının (2017) önerdiği scaled dot-product attention mekanizmasında Query, Key ve Value vektörleri kullanılıyor. Bu vektörler aracılığıyla token’lar arasındaki ilişkiler hesaplanıyor.</p><p>İnsanlar böyle bir cümleyi yorumlarken kelimeler arasındaki ilişkileri ve dünya bilgilerini kullanıyor. <strong>Self-attention</strong> da modelin bir token’ın temsilini oluştururken dizideki diğer token’lardan ne akdar bilgi alacağını öğrenmesini sağlıyor. Tabii bunu insan gibi bilinçli şekilde dikkatini yönelterek yapmıyor. Öğrenilmiş matris işlemleriyle sayısal ağırlıklar hesaplıyor.</p><p>Transformer’da self-atttention hesaplaması için üç temel kavram kullanılıyor:</p><ul><li><strong>Query (Q):</strong> Şu anda hangi bilgiyi arıyoruz?</li><li><strong>Key (K):</strong> Diğer token’lar hangi tür bilgilerle eşleşebilir?</li><li><strong>Value (V):</strong> Eşleşen token’lardan hangi bilgiyi alacağız?</li></ul><p>Bunlar metinden elle çıkarılmış sorular veya etiketler değil. Modelin öğrendiği doğrusal dönüşümlerle elde edilen vektörler.</p><p>Önce Query ve Key vektörleri arasındaki benzerlikler hesaplanıyor. Ardından bu değerler ölçekleniyor ve softmax işleminden geçiriliyor.</p><p>Sonuçta her token için diğer token’lara dağıtılmış attention ağırlıkları elde ediliyor.</p><p>Bu ağırlıklarla Value vektörlerinin ağırlıklı toplamı alınarak yeni bir temsil oluşturuluyor.</p><p><em>Token’lar arasındaki ilişkileri hesapla, bu ilişkileri ağırlıklara dönüştür ve ilgili bilgileri bir araya getir.</em></p><p>Transformer tek bir attention hesabıyla yetinmiyor. Birden fazla attention head kullanarak farklı öğrenilmiş temsil alt uzaylarında ilişkiler kurabiliyor. Bu, modelin farklı türde dilsel örüntüleri yakalayabilmesine katkı sağlayabiliyor. Ancak her attention head’in mutlaka belirli bir dil bilgisi kuralına karşılık geldiğini düşünmemeliyiz.</p><p>Buraya kadar Transformer’dan söz ettik şimdi BERT’e geçebiliriz.</p><p>Devlin ve arkadaşları (2019), BERT modelini tanıtarak Transformer encoder yapısının çift yönlü bağlamsal temsiller öğrenmek için nasıl kullanılabileceğini gösterdi.</p><p><strong>BERT,</strong> <em>Bidirectional Encoder Represantations from Transformers</em> ifadesinin kısaltması. Transformer’ın encoder bileşenini temel alan bir dil modeli. Burada çift yönlü yani bidirectional ifadesi önemli. BERT, bir token’ın temsilini oluştururken hem solundaki hem sağındaki bağlamdan yararlanabiliyor.</p><p>BERT’ün orijinal ön eğitim görevlerinden biri olan MAsked Language Modeling (MLM), bazı token’ları gizleyerek modelin bunları çevresindeki bağlamdan tahmin etmesini sağlıyor. Model bu süreçte yalnzıca tek tek kelimeleri değil, kelimelerin birlikte nasıl kullanıldığına ilişkin pek çok örüntüyü de öğreniyor. BERT’ün orijinal ön eğitiminde Next Sentence Prediction adlı ikinci bir görev de kullanılmıştı. Ön eğitim tamamlandıktan sonra BERT’ü farklı görevlere uyarlayabiliyoruz.</p><p>Örneğin bir metnin hangi sınıfa ait olduğunu tahmin etmek istiyorsak BERT’ün üzerine bir sınıflandırma katmanı ekleyebiliriz. Bu işleme <strong>fine-tuning</strong> diyoruz. Yani modeli sıfırdan eğitmek yerine, daha önce öğrendiği genel dil temsillerini belirli bir problem için uyarlıyoruz.</p><p>Burada Türkçe açısından ilginç bir noktaya geliyoruz. Türkçe eklemeli bir dil. Kelimelerin sonuna gelen eklerle zaman, kişi, olumsuzluk ve başka pek çok dil bilgisel özellik ifade edilebiliyor. Bu durum, tokenization ve dil modelleme süreçlerinde önemli bir rol oynuyor.</p><p>Türkçe için geliştirilen modellerden biri de Schweter’in (2020) yayımladığı BERTurk. Türkçe metinler üzerinde önceden eğitilen bu modeli Hugging Face üzerinden kullanabiliyoruz.:</p><pre>dbmdz/bert-base-turkish-cased</pre><p>Örneğin Python’da tokenizer’ı yüklemek oldukça kolay:</p><pre>from transformers import AutoTokenizer<br><br>tokenizer = AutoTokenizer.from_pretrained(<br>    &quot;dbmdz/bert-base-turkish-cased&quot;<br>)<br><br>text = &quot;Harika, yine bütün işler bana kaldı.&quot;<br><br>tokens = tokenizer.tokenize(text)<br><br>print(tokens)</pre><p>Bu kodu çalıştırdığımızda cümlenin BERTurk tokenizer’ı tarafından hangi token’lara ayrıldığını görebiliriz. Token’ların nasıl parçalandığını görmek küçük ama önemli bir başlangıç. Çünkü bir modelin metni nasıl işlediğini anlamak istiyorsak önce modele gerçekte ne verdiğimizi bilmemiz gerekiyor. Bir sonraki yazıda bu kısmı daha ayrıntılı inceleyeceğiz.</p><p><strong>Baştaki soruya dönelim: BERT gerçekten anlıyor mu?</strong></p><p>Artık BERT’ün metinleri nasıl işlediğine ilişkin biraz daha fikrimiz var. Kelimeler token’lara ayrılıyor, sayısal temsillere dönüştürülüyor ve Transformer katmanlarında bağlamsal bilgilerle güncelleniyor.</p><p>Peki bütün bunlar anlamak demek mi?</p><p>Bu sorunun cevabı biraz da “anlamak” derken neyi kastettiğimize bağlı. BERT’ün dilsel örüntüleri ve bağlamsal ilişkileri öğrenebildiğini biliyoruz. Bu nedenle metin sınıflandırma gibi birçok görevde oldukça yararlı. Ancak bir cümlenin gerçek dünyadaki niyetini, toplumsal bağlamını veya konuşanın deneyimini her zaman doğru yorumlayabildiğini söyleyemeyiz. Özellikle ironi ve örtük söylem gibi konular bunu daha da ilginç hale getiriyor.</p><p>Mesela şu ifadeyi düşünelim:</p><blockquote><em>“Elbette herkes eşit haklara sahip olmalı ama bazı talepler de biraz abartılıyor.”</em></blockquote><p>Burada ilk bölüm destekleyici görünürken ikinci bölüm bu desteği sınırlandırıyor olabilir. Böyle bir ifadeyi değerlendirmek için yalnızca olumlu veya olumsuz kelimeleri bulmak yeterli değil. Modelin cümledeki karşıtlığı, kullanılan bağlaçları ve söylemin bağlamını da hesaba katması gerekiyor. Üstelik bazen cümlenin tek başına yeterli olmadığı durumlar da var.</p><p>Bu yüzden dil modellerinin neyi öğrendiği kadar, <strong>nerede hata yaptığıyla</strong> da ilgilenmemiz gerekiyor.</p><p>BERT ve Transformer’ların bu kadar ilgi çekici olmasının nedeni, metni işlemek için bize güçlü bir yöntem sunmaları. Ama benim için asıl merak uyandıran nokta, modellerin başarılı olduğu örneklerden çok zorlandığı örnekler. Bir model açıkça yazılmış bir düşünceyi sınıflandırabilir. Peki düşünce doğrudan ifade edilmediğinde ne olur? Bir cümle destekleyici kelimeler içerdiği halde aslında destekleyici değilse? Ya da aynı ifade, bağlam değiştiğinde tamamen farklı bir anlam kazanıyorsa?</p><p>İşte NLP’yi araştırmaya değer kılan sorulardan bazıları bunlar.</p><p>Bu seride Transformer modellerini yalnızca kullanmakla kalmayıp, içlerinde neler olduğunu ve sonuçlarını nasıl değerlendirmemiz gerektiğini de anlamaya çalışacağız.</p><p><strong>Bir sonraki yazıda:</strong> <em>Bir Cümle Nasıl Sayılara Dönüşür? Tokenization ve Embedding</em></p><p>Bir Türkçe cümleyi BERTurk’a verip token’lara, token ID’lerine ve embedding temsillerine nasıl dönüştüğünü Python ile adım adım inceleyeceğiz.</p><p><strong>Kaynakça</strong></p><p>Devlin, J., Chang, M.-W., Lee, K., &amp; Toutanova, K. (2019). BERT: Pre-training of deep bidirectional transformers for language understanding. <em>Proceedings of NAACL-HLT 2019</em>, 4171–4186. <a href="https://doi.org/10.18653/v1/N19-1423">https://doi.org/10.18653/v1/N19-1423</a></p><p>Mikolov, T., Chen, K., Corrado, G., &amp; Dean, J. (2013). Efficient estimation of word representations in vector space. <em>arXiv</em>. <a href="https://arxiv.org/abs/1301.3781">https://arxiv.org/abs/1301.3781</a></p><p>Schweter, S. (2020). <em>BERTurk — BERT models for Turkish</em> [Model repository]. GitHub. <a href="https://github.com/stefan-it/turkish-bert">https://github.com/stefan-it/turkish-bert</a></p><p>Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł., &amp; Polosukhin, I. (2017). Attention is all you need. <em>Advances in Neural Information Processing Systems, 30</em>. <a href="https://arxiv.org/abs/1706.03762">https://arxiv.org/abs/1706.03762</a></p><p>Wu, Y., et al. (2016). Google’s neural machine translation system: Bridging the gap between human and machine translation. <em>arXiv</em>. <a href="https://arxiv.org/abs/1609.08144">https://arxiv.org/abs/1609.08144</a></p><p><strong>Kullanılan araçlar</strong></p><p>Hugging Face. (t.y.). <em>Transformers documentation</em>. <a href="https://huggingface.co/docs/transformers">https://huggingface.co/docs/transformers</a></p><p>Hugging Face. (t.y.). <em>dbmdz/bert-base-turkish-cased</em>. <a href="https://huggingface.co/dbmdz/bert-base-turkish-cased">https://huggingface.co/dbmdz/bert-base-turkish-cased</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c3de3cd1acc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Clean Architecture ve Modern C# ile Sürdürülebilir API Geliştirme Rehberi: Uzayan Metotları ve Kod…]]></title>
            <link>https://medium.com/@baskinozge24/clean-architecture-ve-modern-c-ile-s%C3%BCrd%C3%BCr%C3%BClebilir-api-geli%C5%9Ftirme-rehberi-uzayan-metotlar%C4%B1-ve-kod-c21417a2087d?source=rss-789917af4e61------2</link>
            <guid isPermaLink="false">https://medium.com/p/c21417a2087d</guid>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Özge]]></dc:creator>
            <pubDate>Wed, 30 Sep 2026 11:10:02 GMT</pubDate>
            <atom:updated>2026-09-30T11:10:02.306Z</atom:updated>
            <content:encoded><![CDATA[<h3>Clean Architecture ve Modern C# ile Sürdürülebilir API Geliştirme Rehberi: Uzayan Metotları ve Kod Yığınlarını Ayıklamak: Extension Methods ve Fluent API Sanatı</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z54pezAe-OAJoywhAYNpXg.png" /><figcaption>Yazının kapak görseli yapay zeka (DALL-E) desteğiyle tasarlanmıştır</figcaption></figure><p>Serimizin ilk iki bölümünde metotlarımızın giriş kapısını Guard Clauses ile temizledik ve iş mantığı hatalarını Result Pattern ile type safety bir şekilde yönetmeyi öğrendik.</p><p>Ancak projelerimiz büyüdükçe servislerimizin içinde yeni bir problem baş gösterir: Zincirleme işlemler, uzun dönüşümler ve okunabilirliği düşüren yardımcı metot kalabalığı.</p><p>Sürekli Helper.CalculateTax(user.Profile, ...) veya iç içe geçmis karmaşık mantıklar yazmak, kodun nesne yönelimli (OOP) akışını bozar ve okunabilirliği zedeler. Peki, C# dilinin bize sunduğu <strong>Extension Metotları </strong>kullanarak kendi akıcı arayüzlerimizi nasıl tasarlayabiliriz?</p><h3>Geleneksel Yardımcı Sınıf (Helper/Utility) Kullanımı</h3><p>Bir senaryo düşünelim: Kullanıcı işlemlerinden sonra loglama, e-posta formatı kontrolü veya veri dönüşümleri yapıyoruz. Geleneksel yaklaşımda genellikle şu tarz statik sınıflar (Static Helper Classes) kurarız:</p><pre>public static class UserHelper<br>{<br>    public static bool CheckEmailDomain(User user)<br>    {<br>        return user.Email.EndsWith(&quot;@company.com&quot;);<br>    }<br><br>    public static string FormatName(User user)<br>    {<br>        return $&quot;{user.FirstName.ToUpper()} {user.LastName}&quot;;<br>    }<br>}</pre><p>Bunu serviste kullandığımızda kod şöyle görünür:</p><pre>var isValidDomain = UserHelper.CheckEmailDomain(user);<br>var formattedName = UserHelper.FormatName(user);</pre><p>Bu yöntem çalışır; ancak nesne odaklı dillerin bize sunduğu o akıcı (fluent) deneyimi ortadan kaldırır. user.CheckEmailDomain() yerine dışarıdan bir sınıfa nesne parametresi geçmek kodun okunma akışını koparır.</p><h3>Çözüm: Extension Methods ile Akıcı Bir Dünya Kurmak</h3><p>C# dilindeki this anahtar kelimesi, aslında bize ait olmayan veya statik bir sınıfta hapsolmuş metotları, sanki o nesnenin kendi yerleşik metoduymuş gibi çağırmamıza olanak tanır.</p><p>Yukarıdaki dağınık UserHelper yapısını, modern ve akıcı birer <strong>Extension Method</strong> haline getirelim:</p><pre>public static class UserExtensions<br>{<br>    // Kullanıcının e-posta domain kontrolü<br>    public static bool HasValidCompanyDomain(this User user)<br>    {<br>        ArgumentNullException.ThrowIfNull(user);<br>        return user.Email.EndsWith(&quot;@company.com&quot;, StringComparison.OrdinalIgnoreCase);<br>    }<br><br>    // İsmi biçimlendirme<br>    public static string GetFormattedFullName(this User user)<br>    {<br>        ArgumentNullException.ThrowIfNull(user);<br>        return $&quot;{user.FirstName.ToUpperInvariant()} {user.LastName}&quot;;<br>    }<br>}</pre><p>Bu extension metotları yazdıktan sonra servis katmanımızdaki (veya iş mantığımızdaki) kullanım şekli tamamen değişir:</p><pre>public void ProcessUser(User user)<br>{<br>    // Geleneksel: UserHelper.CheckEmailDomain(user);<br>    // Modern Extension Yaklaşımı:<br>    <br>    if (!user.HasValidCompanyDomain())<br>    {<br>        throw new InvalidOperationException(&quot;Geçersiz e-posta domaini.&quot;);<br>    }<br><br>    var fullName = user.GetFormattedFullName();<br>    // İşlemlere devam et...<br>}</pre><p>Bakın, kod artık user.HasValidCompanyDomain() şeklinde doğal bir İngilizce cümle gibi akıyor. Nesne yönelimli programlamanın akışını bozmadan, kodumuzu dışarıdan nasıl zenginleştirdiğimizi fark ettiniz mi?</p><h3>Zincirleme İşlemler (Fluent Chaining)</h3><p>Extension metotların en büyük gücü, metotların arkaya arkaya (zincirleme şekilde) bağlanabilmesidir (Fluent Interface). Önceki bölümlerde yazdığımız Result&lt;T&gt; yapısı ile Extension metotları birleştirdiğimizde ortaya muhteşem bir mimari çıkar:</p><pre>public static class ResultExtensions<br>{<br>    // Result nesnesini bozmadan başarılı durumda ek bir işlem yapma (Tap metodu)<br>    public static Result&lt;T&gt; OnSuccess&lt;T&gt;(this Result&lt;T&gt; result, Action&lt;T&gt; action)<br>    {<br>        if (result.IsSuccess)<br>        {<br>            action(result.Value);<br>        }<br>        return result;<br>    }<br>}</pre><p>Servis katmanında bu akışı şu şekilde zincirleme olarak kullanabilirsiniz:</p><pre>public Result&lt;UserDto&gt; RegisterUser(RegisterDto dto)<br>{<br>    // Guard clauses ile başlangıç kontrolü<br>    ArgumentNullException.ThrowIfNull(dto);<br><br>    // İş mantığı ve Fluent zincirleme<br>    var userResult = _userService.Create(dto);<br><br>    return userResult<br>        .OnSuccess(user =&gt; _emailService.SendWelcomeEmail(user.Email))<br>        .OnSuccess(user =&gt; _logger.LogInformation($&quot;Kayıt başarılı: {user.Id}&quot;));<br>}</pre><p>Kod artık sadece çalışan bir algoritma değil, adeta okuduğunuz bir hikaye haline geliyor!</p><p>Özetle; Clean Architecture ve Modern C# Serisi Bize Ne Kattı?</p><p>Bu 3 bölümlük mini serimizde, projelerimizi bir üst seviyeye taşıyan şu kritik pratikleri ele aldık:</p><ol><li><strong>Bölüm 1 (Guard Clauses):</strong> Metotlarımızın giriş kapısını temizleyerek if-else karmaşıklığından kurtulduk.</li><li><strong>Bölüm 2 (Result Pattern):</strong> Exception maliyetlerinden kaçınıp iş mantığı hatalarını tip güvenli yönettik.</li><li><strong>Bölüm 3 (Extension Methods):</strong> Kodumuzu nesne yönelimli, akıcı ve okunabilir bir formata taşıdık.</li></ol><p>Yazılım sadece bilgisayara komut vermek değildir; gelecekteki kendinize ve ekibinize bırakacağınız en temiz mirastır.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c21417a2087d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Clean Architecture ve Modern C# İle Sürdürülebilir API Geliştirme Rehberi: Service Katmanını…]]></title>
            <link>https://medium.com/@baskinozge24/clean-architecture-ve-modern-c-i%CC%87le-s%C3%BCrd%C3%BCr%C3%BClebilir-api-geli%C5%9Ftirme-rehberi-service-katman%C4%B1n%C4%B1-4cd7159ecdbc?source=rss-789917af4e61------2</link>
            <guid isPermaLink="false">https://medium.com/p/4cd7159ecdbc</guid>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[csharp]]></category>
            <dc:creator><![CDATA[Özge]]></dc:creator>
            <pubDate>Tue, 29 Sep 2026 17:30:22 GMT</pubDate>
            <atom:updated>2026-09-29T17:30:22.837Z</atom:updated>
            <content:encoded><![CDATA[<h3>Clean Architecture ve Modern C# İle Sürdürülebilir API Geliştirme Rehberi: Service Katmanını Şişirmeden İş Mantığını Yönetmek: Result Pattern</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bOZku_AX-rKTYAatxB0mMw.png" /><figcaption>Yazının kapak görseli yapay zeka (DALL-E) desteğiyle tasarlanmıştır</figcaption></figure><p>Serinin ilk yazısında metotlarımızın girişindeki teknik parametre doğrulamalarını <strong>Guard Clauses</strong> ile nasıl temiz hale getireceğimizi inceledik. Peki ya metot içeriğinde veritabanı sorgularında veya iş kurallarında bir şeyler ters gittiğinde ne yapıyoruz?</p><p>Klasik .NET alışkanlığımız hemen bir Exception fırlatmaktır (throw new KeyNotFoundException(), throw new InvalidOperationException()). Ancak büyük ve sürdürülebilir projeler büyüdükçe, iş mantığı hataları için Exception fırlatmanın getirdiği dezavantajlarla karşılaşabiliriz.</p><p>Peki, servis katmanımızı try-catch kalabalığından kurtarmanın ve hataları tip güvenli (type-safe) bir şekilde yönetmenin modern yolu nedir? Cevap: <strong>Result Pattern</strong>.</p><h3>Geleneksel Yaklaşım Neden Tıkanır?</h3><p>Bir kullanıcı profili güncelleme servisi yazdığımızı ve kullanıcının veritabanında olup olmadığını kontrol ettiğimizi düşünelim:</p><pre>public void UpdateUserEmail(int userId, string newEmail)<br>{<br>    ArgumentOutOfRangeException.ThrowIfLessThanOrEqual(userId, 0);<br>    ArgumentException.ThrowIfNullOrWhiteSpace(newEmail);<br><br>    var user = _userRepository.GetById(userId);<br>    <br>    // Klasik Exception fırlatma yöntemi<br>    if (user == null)<br>    {<br>        throw new KeyNotFoundException(&quot;Kullanıcı sistemde bulunamadı.&quot;);<br>    }<br><br>    user.Email = newEmail;<br>    _userRepository.Update(user);<br>}</pre><p>Peki bu yaklaşımın dezavantajları nelerdir?</p><ol><li><strong>Performans Maliyeti:</strong> C# dünyasında bir Exception nesnesi üretmek (stack trace toplamak maliyetlidir) performans açısından ciddi bir yük getirir. “Kullanıcı bulunamadı” gibi senaryolar olağandışı birer sistem çökmesi (exception) değil sıradan iş mantığı sonuçlarıdır.</li><li><strong>Akışın Kopması: </strong>Exception fırlatmak kodun normal akışını keser ve kontrolü en üstteki try-catch bloklarına fırlatır. Bu da metodun ne tür hatalar fırlatabileceğini imza seviyesinde (signature level) belirsiz hale getirir.</li></ol><h3>Çözüm: Kendi Result Sınıfımızı Sıfırdan Tasarlamak</h3><p>Fonksiyonel programlama dünyasından ödünç aldığımız <strong>Result Pattern</strong>, bir işlemin başarılı olup olmadığını, başarılıysa veriyi, başarısızsa hata mesajını sarmalayan hafif ve generic nesneler kullanma prensibidir.</p><p>Projenize hemen entegre edebileceğiniz, sade ama son derece güçlü temel Result ve Result&lt;T&gt; sınıflarımız şöyle görünür:</p><pre>public class Result<br>{<br>    public bool IsSuccess { get; }<br>    public string ErrorMessage { get; }<br>    public bool IsFailure =&gt; !IsSuccess;<br><br>    protected Result(bool isSuccess, string errorMessage)<br>    {<br>        IsSuccess = isSuccess;<br>        ErrorMessage = errorMessage;<br>    }<br><br>    public static Result Success() =&gt; new(true, string.Empty);<br>    public static Result Failure(string errorMessage) =&gt; new(false, errorMessage);<br>}<br><br>public class Result&lt;T&gt; : Result<br>{<br>    public T Value { get; }<br><br>    private Result(T value, bool isSuccess, string errorMessage) <br>        : base(isSuccess, errorMessage)<br>    {<br>        Value = value;<br>    }<br><br>    public static Result&lt;T&gt; Success(T value) =&gt; new(value, true, string.Empty);<br>    public static Result&lt;T&gt; Failure(string errorMessage) =&gt; new(default!, false, errorMessage);<br>}</pre><p>Bu yapı sayesinde her metodumuzun dönüş tipi artık bize o işlemin sonucu hakkında net bir contract sunar.</p><h3>Service ve API Katmanında Result Pattern Kullanımı</h3><pre>public Result&lt;bool&gt; UpdateUserEmail(int userId, string newEmail)<br>{<br>    ArgumentOutOfRangeException.ThrowIfLessThanOrEqual(userId, 0);<br>    ArgumentException.ThrowIfNullOrWhiteSpace(newEmail);<br><br>    var user = _userRepository.GetById(userId);<br>    <br>    // Exception fırlatmak yerine Result.Failure dönüyoruz!<br>    if (user == null)<br>    {<br>        return Result&lt;bool&gt;.Failure(&quot;Kullanıcı sistemde bulunamadı.&quot;);<br>    }<br><br>    user.Email = newEmail;<br>    _userRepository.Update(user);<br><br>    return Result&lt;bool&gt;.Success(true);<br>}</pre><h3>API Controller Tarafında Karşılama</h3><p>Servisimiz artık patlayan bir yapı yerine, sonucunu açıkça bildiren bir contract’e sahip oldu. Controller katmanında bu sonucu işlemek son derece temizdir:</p><pre>[HttpPut(&quot;{id}/email&quot;)]<br>public IActionResult UpdateEmail(int id, [FromBody] UpdateEmailDto dto)<br>{<br>    var result = _userService.UpdateUserEmail(id, dto.NewEmail);<br><br>    if (result.IsFailure)<br>    {<br>        return BadRequest(result.ErrorMessage); <br>    }<br><br>    return Ok(new { Message = &quot;Email başarıyla güncellendi.&quot; });<br>}</pre><h3>Neden Result Pattern Tercih Etmeliyiz?</h3><ol><li><strong>Öngörülebilirlik (Predictability):</strong> Metodun imzasına (Result&lt;T&gt;) baktığınızda, bu metodun başarısız olabileceğini ve bu durumu nasıl ele almanız gerektiğini anlarsınız. Sürpriz try-catch bloklarına ihtiyaç duymazsınız.</li><li><strong>Performans (Performance):</strong> Beklenen iş kuralı ihlalleri için exception fırlatılmadığından, bellek ve CPU maliyeti minimuma iner.</li><li><strong>Temiz Kod (Clean Code):</strong> API katmanınız ile servis katmanınız arasındaki iletişim standartlaşır.</li></ol><p>Yazılım geliştirmek sadece kodu çalıştırmak değil, kodun hikayesini anlaşılır kılmaktır. Exception mekanizmalarını sistem çöküntüleri için saklayıp, iş mantığı sonuçlarını Result Pattern ile yönetmek kodunuzu çok daha profesyonel ve güvenli bir seviyeye taşıyacaktır. Serinin son bölümünde görüşmek üzere!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4cd7159ecdbc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Clean Architecture ve Modern C# İle Sürdürülebilir API Geliştirmek: Guard Clauses]]></title>
            <link>https://medium.com/@baskinozge24/clean-architecture-ve-modern-c-i%CC%87le-s%C3%BCrd%C3%BCr%C3%BClebilir-api-geli%C5%9Ftirmek-guard-clauses-297fbbee8aac?source=rss-789917af4e61------2</link>
            <guid isPermaLink="false">https://medium.com/p/297fbbee8aac</guid>
            <dc:creator><![CDATA[Özge]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 18:37:19 GMT</pubDate>
            <atom:updated>2026-09-28T18:38:29.365Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rIx_tPmbAm1KP27qzgXdPQ.jpeg" /><figcaption>Yazının kapak görseli yapay zeka (DALL-E) desteğiyle tasarlanmıştır</figcaption></figure><p>Yazılım geliştirirken hepimiz benzer bir manzarayla karşılaşmışızdır: Yepyeni bir servis metodu yazarız, her şey harika gider ancak işin içine girdi denetimleri, null kontrolleri, parametre doğrulamaları girdiğinde metot birden şişmeye başlar.</p><p>İlk 15 satır tamamen</p><pre>if (param == null) throw new…</pre><p>kontrolleriyle doludur. Kod sağa doğru ok gibi açılır ve asıl iiş mantığımız bu kalabalığın arasında kaybolur. Peki .NET projelerimizde bu durumdan kurtulmak ve kodumuzu ilk bakışta okunabilir hale getirmek için ne yapmalıyız? <strong>Cevap: Guard Clauses.</strong></p><p>Örnek olarak bir E-Ticaret veya Kullanıcı Yönetim sisteminde yeni bir kullanıcı kaydı oluşturan (veya güncelleyen) tipik bir servis metodunu ele alalım. Geleneksel yöntemle yazılmış bir kod genellikle şöyle görünür:</p><pre>public void UpdateUserProfile(UserUpdateDto dto)<br>{<br>    if (dto != null)<br>    {<br>        if (dto.Id &gt; 0)<br>        {<br>            if (!string.IsNullOrWhiteSpace(dto.Email))<br>            {<br>                if (dto.Age &gt;= 18)<br>                {<br>                    // ==========================================<br>                    // ASIL İŞ MANTIĞI BURADA BAŞLAR (Kod sağa kaydı!)<br>                    // ==========================================<br>                    var user = _userRepository.GetById(dto.Id);<br>                    if (user != null)<br>                    {<br>                        user.Email = dto.Email;<br>                        _userRepository.Update(user);<br>                    }<br>                    else<br>                    {<br>                        throw new KeyNotFoundException(&quot;Kullanıcı bulunamadı.&quot;);<br>                    }<br>                }<br>                else<br>                {<br>                    throw new ArgumentException(&quot;Kullanıcı 18 yaşından küçük olamaz.&quot;);<br>                }<br>            }<br>            else<br>            {<br>                throw new ArgumentException(&quot;Email adresi boş olamaz.&quot;);<br>            }<br>        }<br>        else<br>        {<br>            throw new ArgumentException(&quot;Geçersiz kullanıcı ID değeri.&quot;);<br>        }<br>    }<br>    else<br>    {<br>        throw new ArgumentNullException(nameof(dto));<br>    }<br>}</pre><p>Bu kod çalışır mı? Evet. Sürdürülebilir mi? Kesinlikle hayır. Kodun derinliklerine inmek hem zihinsel yorgunluk yaratır hem de yeni bir kural eklemek istediğimizde hata yapma riskimizi artırır.</p><p>Guard Clauses mantığı oldukça basittir. Metodun en başında geçersiz veya istenmeyen durumları hemen kontrol et ve hata fırlat. Böylece asıl iş mantığınız metodun en solunda, tertemiz ve düz bir akışla başlar. Yukarıda bahsettiğimiz senaryoyu guard clauses ile yeniden ele alalım:</p><pre>public void UpdateUserProfile(UserUpdateDto dto)<br>{<br>    // 1. Aşama: Koruma Maddeleri (Guard Clauses)<br>    ArgumentNullException.ThrowIfNull(dto);<br>    ArgumentOutOfRangeException.ThrowIfLessThanOrEqual(dto.Id, 0);<br>    ArgumentException.ThrowIfNullOrWhiteSpace(dto.Email);<br>    <br>    if (dto.Age &lt; 18)<br>        throw new ArgumentException(&quot;Kullanıcı 18 yaşından küçük olamaz.&quot;);<br><br>    // 2. Aşama: Asıl İş Mantığı (Tertemiz ve en solda başlar)<br>    var user = _userRepository.GetById(dto.Id) <br>               ?? throw new KeyNotFoundException(&quot;Kullanıcı bulunamadı.&quot;);<br><br>    user.Email = dto.Email;<br>    _userRepository.Update(user);<br>}<br></pre><p><strong>Küçük Bir Soru: 18 Yaş Kontrolünü Neden Guard Şeklinde Yapmadık?</strong></p><p>Yukarıdaki koda dikkatli baktıysanız gözünüze şu detay çarpmış olabilir: <em>“ID ve Email kontrolleri için hazır Guard metotları kullandık, peki yaş kontrolünü neden düz bir </em><em>if bloğuyla bıraktık?”</em></p><p>Bunun arkasında çok önemli bir mimari ayrım var: <strong>Teknik Doğrulama vs. İş Kuralı (Business Rule).</strong></p><ul><li><strong>Guard Clauses (Teknik Doğrulamalar İçindir):</strong> Id sıfırdan küçük olamaz veya nesne null olamaz. Bunlar uygulamanın çalışabilmesi için teknik olarak zorunlu olan altyapısal şartlardır. Eğer bunlar sağlanmazsa sistem zaten çöker (ArgumentException / NullReference).</li><li><strong>18 Yaş Sınırı (Bir İş Kuralıdır):</strong> Yaş sınırı teknik bir çökme sebebi değildir; sistemin o anki iş mantığına ait bir kısıttır. İleride iş kuralları değişip <em>“18 yaş altı da üye olabilir ama veli onayı gerekir”</em> denebilir. Bu tip iş kuralları, metodun girişindeki temel teknik koruma maddelerinden ayrı tutulur veya ileride göreceğimiz daha gelişmiş yapılarla yönetilir.</li></ul><p>Bu ayrımı gözetmek, kodunuzun sorumluluklarını (Separation of Concerns) doğru yerleştirmenizi sağlar.</p><p><strong>.NET Kendi İçinde Bize Ne Sunuyor?</strong></p><p>.NET 6 ve sonrasından itibaren kendi if bloklarımızı yazmamıza ya da dış kütüphanelere ihtiyaç duymamıza gerek kalmadan kullanabileceğimiz yerleşik metotlar sağlandı. Bunları kullanmak için ekstra paket kurulumu yapmanıza gerek yok. Bu yerleşik metotlardan bazılarına bakalım:</p><pre>ArgumentNullException.ThrowIfNull(param): Parametre null ise ArgumentNullException fırlatır.</pre><pre>ArgumentException.ThrowIfNullOrEmpty(stringParam): String ifade null veya boşsa hata fırlatır.</pre><pre>ArgumentOutOfRangeException.ThrowIfLessThanOrEqual(value, 0): Sayısal değer belirtilen sınırdan küçük veya eşitse hata fırlatır.</pre><p>Bu yerleşik metotlar hem performans açısından optimize edilmiştir hem de kodunuzu standartlaştırır.</p><p>Kod yazmak sadece bilgisayara komut vermek değildir. Aynı zamanda o kodu okuyacak diğer geliştiricilere ve tabii ki gelecekteki kendimize temiz bir hikaye anlatmaktır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*WMsbSfr3CU0B7Clp.jpg" /><figcaption>Kaynak:<a href="https://twitter.com/hilalmorgull">https://twitter.com/hilalmorgull</a></figcaption></figure><p><strong>Serinin Devamında Ne Var?</strong></p><p>Serinin bu ilk adımında kodumuzu giriş aşamasında nasıl temizleyeceğimizi gördük. Ancak yazılım dünyasında problemler sadece giriş parametreleriyle sınırlı değildir; ya veritabanı işlemlerinde veya iş kurallarında bir hata oluşursa? Her seferinde try-catch blokları yazıp Exception fırlatmak gerçekten doğru bir yaklaşım mı?</p><p>👉 <strong>Serinin İkinci Bölümü:</strong> <em>“Service Katmanını Şişirmeden İş Mantığını Yönetmek: Result Pattern”</em> ile bu soruya modern bir çözüm arayacağız. Takipte kalın!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=297fbbee8aac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[.NET MÜLAKATLARININ VAZGEÇİLMEZİ : GERÇEK HAYAT BENZETİŞLERİYLE DI LIFECYCLES (TRANSIENT, SCOPED…]]></title>
            <link>https://medium.com/@baskinozge24/net-m%C3%BClakatlarinin-vazge%C3%A7i%CC%87lmezi%CC%87-ger%C3%A7ek-hayat-benzeti%CC%87%C5%9Fleri%CC%87yle-di-lifecycles-transient-scoped-920f1f53f78c?source=rss-789917af4e61------2</link>
            <guid isPermaLink="false">https://medium.com/p/920f1f53f78c</guid>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[dependency-injection]]></category>
            <category><![CDATA[interview-questions]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Özge]]></dc:creator>
            <pubDate>Sun, 27 Sep 2026 15:30:28 GMT</pubDate>
            <atom:updated>2026-09-27T15:30:28.525Z</atom:updated>
            <content:encoded><![CDATA[<p>.NET MÜLAKATLARININ VAZGEÇİLMEZİ : GERÇEK HAYAT BENZETİŞLERİYLE DI LİFECYCLES (TRANSIENT, SCOPED, SINGLETON)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sxOIMw4gbnCoy0RBcurV2Q.jpeg" /><figcaption>Yazının kapak görseli yapay zeka (DALL-E) desteğiyle tasarlanmıştır</figcaption></figure><p>Modern yazılım geliştirme dünyasında özellikle .NET ekosisteminde kod yazıyorsanız Dependency Injection (DI)kavramıyla karşılaşmamanız neredeyse imkansızdır. Nesneler arasındaki bağımlılıkları yönetmek, gevşek bağlı (loosely coupled)ve test edilebilir yapılar kurmak için DI bizim en büyük yardımcımız.</p><p>Ancak .AddTransient() AddScoped veya .AddSingleton()metotları projemize eklerken şu soruyu kendimize ne kadar sık soruyoruz:”Bu nesne hafızada (RAM)ne kadar süre canlı kalacakve bunun arka plandaki maliyeti nedir?”</p><p>Bu yazıda teknik tanımlardan biraz daha sıyrılıp nesne ömürlerini (lifecycles) günlük hayattan bir benzetmeyle ele alacağız. Ardından yanlış seçimlerin büyük projelerde ne tür felaketlere yol açabileceğine değineceğiz.</p><p>BİR AKŞAM YEMEĞİ HİKAYESİ</p><p>Gelin .NET içerisindeki IoC Container mekanizmasını yoğun bir restoran olarak haya ledelim. Bu restorana gelen her bir müşteri masası, web uygulamamıza gelen bir HTTP Request olsun. Siparişleri alan ve işleyen personeller ise bizim servislerimiz yani nesnelerimiz. Şimdi Nesne ömürlerini üç farklı çalışan tipiyle anlamaya çalışalım.</p><p>1. Transient (Tek Seferlik Garson)</p><p>Restorandasınız ve masaya her su, ekmek veya çatal istediğinizde mutfaktan tamamen yeni ve daha önce görmediğiniz bir garson çıkıp geliyor. İstediğinizi masaya bırakıyor ve anında yok oluyor. Birdakika sonra tekrar bir şey istediğinizde yine sıfırdan başka bir garson geliyor.</p><p>· .NET Dünyasındaki Karşılığı: Uygulama içinde bu servis her enjekte edildiğinde .NET hafızada sıfırdan yeni bir nesne oluşturur. İşiniz bittiği an bu nesne garbage collector’ devredilmek üzere boşa çıkar.</p><p>2. Scoped (Masaya Özel Garson)</p><p>Restorana giriş yapıp masanıza oturduğunuz an size özel bir garson tanımlanıyor. Siz yemeğinizi yiyip tatlınızı söyleyip hesabı ödeyene kadar tüm isteklerinizle sadece bu garson ilgileniyor. Siz restorandan ayrıldığınızda o garsonun da sizin masanızla olan görevi bitiyor. Yan masanın ise tamamen kendine özel başka bir garsonu var.</p><p>· .NET Dünyasındaki Karşılığı: Web uygulamanıza bir HTTP isteği geldiği anda nesne bir kez oluşturulur. O istek boyunca kodun neresinde çağırılırsa çağırılsınhep aynı nesne kullanılır. İstek sonlanıp istemciye cevap döndüğü an nesnenin ömrü biter.</p><p>3. Scoped (Tüm Restoranın Şef Aşçısı)</p><p>Bu devasa restoranda sadece bir tane şef aşçı var. Sabah restoranın kapıları ilk açıldığında işe başlar. Gün boyu içeri giren yüzlerce farklı müşteri masasına tek başına yemek hazırlar. Akşam dükkan kapanıp ışıklar sönene kadar da mutfaktadır; asla değişmez, yenilenmez.</p><p>· .NET Dünyasındaki Karşılığı: Uygulama ayağa kalktığı anda (veya ilk ihtiyaç duyulduğunda) bu nesne yalnızca bir kez oluşturulur. Uygulama açık olduğu sürece, gelen tüm kullanıcılara ve tüm isteklere hafızadaki aynı tek nesne hizmet eder. Uygulama kapanana kadar RAM&#39;de yaşamaya devam eder.</p><p>TEORİDEN PRATİĞE: HANGİ SERVİSİ NE ZAMAN SEÇMELİYİZ</p><p>Restoran hikayemiz harika bir zemin oluşturdu ancak kod yazarken hangi servisi ne zaman seçeceğimizi bilmemiz gerekiyor. Yanlış bir lifecycle seçimi, uygulamanın yavaşlamasına, bellek sızıntılarına (memory leak) hatta veritabanı kilitlenmelerine yol açabilir.</p><p>Gelin gerçek senaryolar üzerinden inceleyelim:</p><p>1. Ne Zaman .AddTransient() ?</p><p>Eğer oluşturacağınız servis durum (state) bilgisi tutmuyorsa (stateless) ve oldukça &quot;hafif&quot; bir yapıdaysa Transient en doğru seçimdir. Nesne hızlıca oluşturulur, işini yapar ve hafızadan silinir.</p><p>· Gerçek Hayat Örneği: Bir IEmailSender (E-posta gönderme servisi) veya bir IMathCalculator (Matematiksel hesaplamalar yapan bir yardımcı sınıf). Bu sınıfların içinde bir kullanıcının verisi veya açık bir bağlantı tutulmaz; sadece parametreyi alır, işler ve biter.</p><p>2. Ne Zaman .AddScoped() ?</p><p>Aynı HTTP isteği (Request) içerisindeki tüm operasyonların aynı veri kümesi veya bağlantı üzerinden yürümesi gerektiğinde Scoped kullanılır. .NET dünyasındaki en popüler kullanım alanı veritabanı bağlantılarıdır.</p><p>· Gerçek Hayat Örneği: Entity Framework Core kullandıysanız, DbContext yapısının varsayılan olarak Scoped kaydedildiğini bilirsiniz. Bir istek geldiğinde sepete ürün ekleniyor, stok düşülüyor ve log atılıyorsa; tüm bu adımların aynı veritabanı bağlantısı (transaction) üzerinden yürümesi şarttır. İşlem bitince bağlantı güvenle kapatılır.</p><p>3. Ne Zaman .AddSingleton() ?</p><p>Uygulamanın tamamı için tek bir doğruluk kaynağı (single source of truth) olması gereken, oluşturulması maliyetli (ağır) ve tüm kullanıcılar tarafından ortak paylaşılan yapılar için Singleton biçilmiş kaftandır.</p><p>· Gerçek Hayat Örneği: Uygulama ayarlarını okuyan bir IConfiguration servisi, sistemin tamamında kullanılan bir bellek içi önbellek (IMemoryCache) mekanizması veya uygulamanın çalışma durumunu izleyen loglama araçları.</p><p>DİKKAT: CAPTIVE DEPENDENCY</p><p>Geldik bir .NET geliştiricisini mülakatlarda veya kıdemli mimari tartışmalarda bir adım öne geçirecek konuya: Captive Dependency. “Sen bunu biliyorsun da öne geçtin mi?” diye sormayın. Bazen öne geçmek için bilgi değil “network&quot;&quot; adı altında torpil gerekiyor ama o artık başka bir yazının konusu. Yine de sorduysanız cevaplayayım öne falan geçemedim hala işsizim.🤭</p><p>Devam edelim.</p><p>IoC Container yapısının altın bir kuralı vardır: Daha uzun ömürlü bir nesne, daha kısa ömürlü bir nesneyi doğrudan içine enjekte (inject) etmemelidir. Eğer bunu yaparsanız, uzun ömürlü nesne kısa ömürlü olanı kendi ömrü boyunca saklamaya zorlar, yani onu tutsak eder.</p><p>Hatalı bir kod örneği üzerinden bu durumu inceleyelim.</p><p>Diyelim ki sistemde uygulama boyunca tek bir örneği yaşayacak bir Singleton servisiniz var ve bu servisin içinden veritabanına erişmek için Scoped olan DbContext&#39;i çağırdınız:</p><pre>// Singleton olarak kaydedilmiş bir servis<br><br>public class CacheManager : ICacheManager<br><br>{<br><br>    private readonly<br>ApplicationDbContext _context; // Yanlış enjeksiyon! (Scoped)<br><br> <br><br>    public<br>CacheManager(ApplicationDbContext context)<br><br>    {<br><br>        _context = context;<br><br>    }<br><br> <br><br>    public void RefreshCache()<br><br>    {<br><br>        var data =<br>_context.Products.ToList();<br><br>        // Önbellek tazeleme<br>işlemleri...<br><br>    }<br><br>}<br><br><br><br></pre><p>❌️ Bu Kod Neden Patlar?</p><p>CacheManager (Singleton) uygulama kapanana kadar sadece bir kez oluşturulur. İçine enjekte edilen ApplicationDbContext (Scoped) de o ilk oluşturulma anında bir kere çekilir ve CacheManager&#39;ın içinde hapsedilir.</p><p>Normalde her HTTP isteği sonunda kapanması ve hafızadan temizlenmesi gereken veritabanı bağlantısı, Singleton servis yüzünden asla kapanmaz. Uygulama çalıştığı sürece o bağlantı açık kalır. Sonuç? Bir süre sonra veritabanı havuzundaki (Connection Pool) tüm bağlantılar tükenir ve uygulamanız Timeout hataları vererek çöker.</p><p>✅️ Çözüm Nedir?<br>Eğer bir Singleton servis içinde Scoped bir servise mecburen ihtiyaç duyuyorsanız, onu constructor (yapıcı metot) içinde enjekte etmek yerine, metot içinde IServiceProvider veya IServiceScopeFactory kullanarak manuel bir yaşam alanı (scope) oluşturmalı ve işiniz bittiğinde o scope’u kapatmalısınız.</p><p>.NET dünyasında Dependency Injection kullanmak sadece servisleri birbirine bağlamaktan ibaret değildir; uygulamanın performansını, bellek yönetimini ve sürdürülebilirliğini doğrudan belirleyen mimari bir karardır.</p><p>Projelerinizde nesne ömürlerini belirlerken kendinize her zaman şu soruyu sorun: &quot;Bu garsonun masada ne kadar kalmaya hakkı var?&quot; Doğru lifecycle seçimi, sizi gelecekte karşılaşacağınız memory leak hatalarından ve veritabanı çökmelerinden kurtaracaktır.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=920f1f53f78c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python’da Paralel Programlama: CPU’dan GPU’ya Performans Yolculuğu-2]]></title>
            <link>https://medium.com/@baskinozge24/pythonda-paralel-programlama-cpu-dan-gpu-ya-performans-yolculu%C4%9Fu-2-007917fe757a?source=rss-789917af4e61------2</link>
            <guid isPermaLink="false">https://medium.com/p/007917fe757a</guid>
            <category><![CDATA[parallel-processing]]></category>
            <category><![CDATA[cpu]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[begginer]]></category>
            <category><![CDATA[parallel-computing]]></category>
            <dc:creator><![CDATA[Özge]]></dc:creator>
            <pubDate>Sun, 10 Aug 2025 13:20:14 GMT</pubDate>
            <atom:updated>2025-08-10T13:21:37.652Z</atom:updated>
            <content:encoded><![CDATA[<p><a href="https://medium.com/@baskinozge24/paralel-programlamaya-giri%C5%9F-cpu-%C3%BCzerinde-python-ile-paralel-programlama-9fd3fd56b476">Önceki yazımızda</a> Python ile CPU üzerinde paralel programlamaya giriş yaparak seri ve paralel hesaplamalar arasındaki temel farkları gördük. Bu yazıda, paralel programlamayı daha derinlemesine keşfedecek ve gerçek hayatta karşılaşacağımız önemli konulara değineceğiz. Ayrıca GPU programlamaya giriş yaparak, grafik işlemcilerin nasıl yüksek performans sağladığını da öğreneceğiz.</p><h4><strong>İş Parçalama (Task Decomposition) ve İş Yükünün Verimli Bölünmesi</strong></h4><p><strong>Neden önemli?</strong><br> Paralel programlama yaparken, işi tek parça halinde tüm çekirdeklere vermek mümkün değil. İşin küçük parçalara bölünüp, bu parçaların işlemcilere dengeli şekilde dağıtılması gerekir. Eğer parçalar dengesiz olursa, bazı çekirdekler işsiz kalır, bazıları ise aşırı yüklü olur. Bu da paralel programlamanın hız kazandırma amacını boşa çıkarır.</p><p><strong>Ne yapıyoruz?</strong></p><ul><li>İşimizi (örneğin 1 milyon sayı ile işlem yapmak) küçük parçalara bölüyoruz (örneğin 4 parçaya).</li><li>Her parçayı bir çekirdeğe gönderiyoruz.</li><li>Tüm parçalar bağımsız olarak çalışıyor.</li><li>Sonunda parçaları birleştirip sonucu elde ediyoruz.</li></ul><h4><strong>Veri Paylaşımı ve Senkronizasyon</strong></h4><p><strong>Neden önemli?</strong><br> Paralel çalışan işlemler aynı verilere aynı anda erişirse, veriler bozulabilir. Buna “race condition” denir ve hatalara sebep olur. Mesela iki işlem aynı listeye aynı anda veri eklemek isterse, listenin yapısı bozulabilir.</p><p><strong>Ne yapıyoruz?</strong></p><ul><li>Paylaşılan verileri özel yapılarla tutuyoruz (multiprocessing.Manager gibi).</li><li>Veri erişimi sırasında <strong>kilit (lock)</strong> mekanizması kullanarak aynı anda sadece bir işlemin veriye erişmesini sağlıyoruz.</li><li>Böylece veriler korunmuş olur.</li></ul><p>Bununla ilgili bir kod örneği inceleyelim:</p><pre>from multiprocessing import Process, Manager, Lock<br><br>def listeye_ekle(paylasilan_liste, veri, lock):<br>    with lock:<br>        paylasilan_liste.append(veri)<br><br>if __name__ == &quot;__main__&quot;:<br>    manager = Manager()<br>    paylasilan_liste = manager.list()<br>    lock= Lock()<br>    prosesler = []<br><br>    for i in range(5):<br>        p = Process(target=listeye_ekle, args=(paylasilan_liste, i, lock))<br>        prosesler.append(p)<br>        p.start()<br><br>    for p in prosesler:<br>        p.join()<br><br>    print(list(paylasilan_liste))</pre><h4>1. Manager (Yönetici)</h4><ul><li>multiprocessing.Manager(), Python’da <strong>farklı process’lerin (işlemlerin) aralarında veri paylaşabilmesi</strong> için bir “yönetici” nesnesi sağlar.</li><li>Normalde her process kendi hafızasında çalışır ve değişkenleri diğer process’lerden <strong>bağımsızdır</strong>.</li><li>Manager sayesinde, örneğin ortak bir liste, sözlük gibi <strong>paylaşılan veri yapıları</strong> yaratabilir ve tüm process’ler bu yapıya erişip üzerinde işlem yapabilir.</li><li>manager.list() dediğimizde, tüm process’ler tarafından erişilebilen paylaşılan bir liste oluşturuyoruz.</li></ul><h4>2. Lock (Kilitleme)</h4><ul><li>Paralel çalışan process’ler aynı anda paylaşılan veriye erişirse, veriler <strong>karışabilir veya bozulabilir</strong>.</li><li>Örneğin, aynı anda iki işlem listenin sonuna ekleme yapmaya çalışırsa, listenin yapısı bozulabilir. Buna <strong>race condition (yarış durumu)</strong> denir ve hata kaynağıdır.</li><li>Lock() bu sorunu önler.</li><li>Lock, <strong>aynı anda sadece bir process’in kritik bölgeye (paylaşılan veriye erişim yapılan kısma) girmesini sağlar.</strong></li><li>with lock: ifadesi, o kod bloğuna girildiğinde kilidi “alır”, bitince “bırakır”. Böylece diğer process’ler beklemek zorunda kalır ve veri güvenliği sağlanır.</li></ul><h4>3. Process</h4><ul><li>Python’da multiprocessing.Process farklı çalışan bağımsız işlem birimleridir.</li><li>Her biri kendi belleğine sahiptir ancak Manager ve Lock ile ortak veri üzerinde kontrol sağlanabilir.</li></ul><h4>Kısaca Özetlersek:</h4><ul><li><strong>Manager:</strong> Paylaşılan veri yapıları oluşturur (liste, sözlük vb.) ve bunları farklı process’ler arasında erişilebilir yapar.</li><li><strong>Lock:</strong> Paylaşılan veriye erişim sırasında race condition önlemek için kritik bölgeyi kilitler.</li><li><strong>Process:</strong> Paralel çalışan bağımsız işlem birimidir.</li></ul><h4><strong>Thread vs Process ve GIL (Global Interpreter Lock)</strong></h4><ul><li><strong>Process (İşlem):</strong><br> İşletim sisteminin kendine ait ayrı bir bellek alanı, kaynakları ve yürütme bağlamı (context) olan bağımsız çalıştırılabilir program birimidir.</li><li>Her process kendi başına bağımsızdır.</li><li>Python’da multiprocessing.Process ile farklı processler oluştururuz.</li><li><strong>Thread (İş Parçacığı):</strong></li><li>Process içindeki daha küçük yürütme birimleridir.</li><li>Aynı process’in belleğini paylaşırlar.</li><li>Python’da threading.Thread kullanılır.</li><li>Thread’ler daha hafif ve oluşturulması daha hızlıdır.</li><li><strong>GIL (Global Interpreter Lock) Nedir?</strong></li><li>Python (özellikle CPython) <strong>GIL</strong> adı verilen bir mekanizma içerir.</li><li>GIL, <strong>aynı anda sadece bir thread’in Python kodunu çalıştırabilmesini sağlar</strong>.</li><li>Sebebi, Python’un belleği ve nesne yapısını korumak için tek iş parçacığının işlem yapmasını garanti altına almak.</li><li>Bu, çok çekirdekli CPU’larda dahi <strong>CPU-ağırlıklı Python kodlarının thread ile paralel hızlanmasını engeller</strong>. Bu yüzden CPU ağırlıklı işlerde çok thread kullanmak beklenen hızlanmayı sağlamaz.</li><li><strong>GIL’in Sonuçları Nedir?</strong></li><li><strong>IO-bound (giriş-çıkış ağırlıklı)</strong> işlemler için threading faydalıdır, çünkü threadler çoğunlukla bekler ve GIL’i bırakır, böylece başka thread’ler çalışabilir.</li><li><strong>CPU-bound (işlemci ağırlıklı)</strong> işlemler için threading performans artışı sağlamaz; hatta bazen yavaşlatır.</li><li>Bu nedenle CPU ağırlıklı işler için <strong>multiprocessing ile process bazlı paralel programlama</strong> tercih edilir. Çünkü her process’in kendi GIL’i vardır (<strong>yani GIL process bazında değil thread bazında çalışır</strong>).</li></ul><h4><strong>Performans Analizi: Profiling ile Kodun Darboğazlarını (Bottleneck) Bulmak</strong></h4><p><strong>Neden Performans Analizi Yapmalıyız?</strong></p><p>Bir programı yazarken:</p><ul><li>Kodumuzun yavaş çalıştığını düşünüyoruz,</li><li>Ya da paralel programlama sonrası hız artışı bekliyoruz ama fark çok az,</li><li>Hangi kısımların en çok zaman aldığını bilmiyorsak iyileştirme yapmak zor olur.</li></ul><p><strong>Profiling</strong> yani performans analizi, programın hangi bölümlerinin ne kadar zaman harcadığını tespit etmek için kullanılır.</p><h4><strong>Python’da Profiling Araçları</strong></h4><p><strong>1. </strong><strong>time modülü (Basit Ölçümler)</strong></p><ul><li>Küçük kod parçalarının süresini ölçmek için.</li><li>Ama ayrıntılı bilgi vermez.</li></ul><pre>import time<br><br>start = time.time()<br><br>for i in range(10**6):<br>    pass<br><br>end = time.time()<br>print(f&quot;Süre: {end - start} saniye&quot;)</pre><p><strong>2. </strong><strong>timeit modülü (Daha hassas zaman ölçümü)</strong></p><ul><li>Küçük fonksiyonların veya ifadelerin süresini hassas şekilde ölçmek için kullanılır.</li><li>Kodu tekrar tekrar çalıştırıp ortalama süreyi verir.</li></ul><pre>import timeit<br><br>def fonksiyon():<br>    sum(range(1000))<br><br>print(timeit.timeit(fonksiyon, number=1000))</pre><p><strong>3. </strong><strong>cProfile modülü (Detaylı Profiling)</strong></p><ul><li>Programdaki her fonksiyonun çağrı sayısı ve süreleri dahil detaylı performans bilgisi verir.</li><li>Bütün programı veya seçtiğiniz fonksiyonları analiz etmek için çok kullanışlıdır.</li></ul><pre>import cProfile<br><br>def hesaplama():<br>    toplam = 0<br>    for i in range(10**6):<br>        toplam += i<br>    return toplam<br><br>cProfile.run(&#39;hesaplama()&#39;)<br></pre><p><strong>Profiling Çıktısı Nasıl Anlaşılır?</strong></p><ul><li>ncalls: Fonksiyon kaç kere çağrıldı?</li><li>tottime: Fonksiyon içinde geçen toplam süre (alt fonksiyonlar hariç).</li><li>percall: Fonksiyon başına ortalama süre (tottime/ncalls).</li><li>cumtime: Fonksiyon ve alt fonksiyonların toplam süresi.</li><li>filename:line(function): Fonksiyonun dosya ve satır bilgisi.</li></ul><h4>Farklı Python Paralel Kütüphaneleri ile Çalışmak</h4><p><strong>Neden Farklı Kütüphaneler?</strong></p><p>Python’da paralel programlama için pek çok kütüphane var. Her kütüphane farklı ihtiyaçlara hitap eder:</p><ul><li>Kodunuzu basitleştirmek istiyorsanız,</li><li>Esnek ve güçlü yapı arıyorsanız,</li><li>Makine öğrenimi gibi özel alanlarda kullanacaksanız,</li><li>İş parçacığı (thread) veya işlem (process) tabanlı paralellik istiyorsanız,</li></ul><p>Farklı kütüphaneler size değişik avantajlar sunar. En yaygın 3 kütüphaneyi inceleyecek olursak:</p><ol><li><strong>concurrent.futures</strong></li></ol><ul><li>Python 3’le birlikte standart kütüphaneye girmiş kolay kullanımlı paralel modül.</li><li>Hem <strong>ThreadPoolExecutor</strong> (thread tabanlı) hem <strong>ProcessPoolExecutor</strong> (process tabanlı) var.</li><li>Basit API ile paralel çalışmayı kolaylaştırır.</li></ul><p>2.<strong> joblib</strong></p><ul><li>Özellikle veri bilimi ve makine öğrenimi alanında çok kullanılan bir kütüphane.</li><li>Paralel işlemleri basitleştirir, özellikle döngüleri paralel çalıştırmak için ideal.</li><li>delayed ve Parallel fonksiyonları ile kullanılır.</li></ul><p>3.<strong>multiprocessing</strong></p><ul><li>Python’un temel paralel programlama kütüphanesi.</li><li>Daha düşük seviyede kontrol sağlar.</li><li>Hem process oluşturma, paylaşılan veri yapıları, kilitler gibi yapıların yönetimi için kullanılır.</li><li>Esnek ama biraz daha karmaşık kod yazımı gerektirir.</li></ul><p>Yukarıda CPU üzerinde paralel programlamanın temellerini ve farklı Python kütüphanelerini ele aldık. Ancak günümüzde yüksek performans gerektiren birçok uygulama — özellikle yapay zeka, derin öğrenme ve büyük veri analizi — CPU’ların yanında <strong>GPU (Grafik İşlem Birimi)</strong> gücünden de yararlanıyor.</p><p>GPU’lar, binlerce çekirdeği sayesinde çok daha büyük ölçekli ve hızlı paralel hesaplamalar yapabiliyor. Bir sonraki yazımızda:</p><ul><li>GPU programlamanın temellerini,</li><li>CUDA ve OpenCL gibi teknolojileri,</li><li>Python’da GPU programlama için kullanılan kütüphaneleri (örneğin PyCUDA, Numba, CuPy),</li><li>Ve gerçek dünya problemlerinde GPU hızlandırmasının nasıl uygulanacağın</li></ul><p>detaylı ve öğretici şekilde ele alacağız.</p><p>Bir sonraki yazıda görüşmek üzere!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=007917fe757a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python’da Paralel Programlama: CPU’dan GPU’ya Performans Yolculuğu-1]]></title>
            <link>https://medium.com/@baskinozge24/paralel-programlamaya-giri%C5%9F-cpu-%C3%BCzerinde-python-ile-paralel-programlama-9fd3fd56b476?source=rss-789917af4e61------2</link>
            <guid isPermaLink="false">https://medium.com/p/9fd3fd56b476</guid>
            <category><![CDATA[cpu]]></category>
            <category><![CDATA[beginners-guide]]></category>
            <category><![CDATA[parallel-computing]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[parallel-processing]]></category>
            <dc:creator><![CDATA[Özge]]></dc:creator>
            <pubDate>Sat, 09 Aug 2025 16:08:33 GMT</pubDate>
            <atom:updated>2025-08-10T13:21:53.849Z</atom:updated>
            <content:encoded><![CDATA[<p>Günümüzde yapay zeka uygulamaları, çok büyük veri setleri ve karmaşık hesaplamalar gerektiriyor. Mesela, bir görüntüyü tanıyan derin öğrenme modeli milyonlarca parametreyle çalışıyor ve devasa sayıda matematiksel işlem yapıyor. Bu kadar yoğun işlemi tek bir çekirdekte seri (tek tek) yapmak hem çok yavaş olur hem de bilgisayarımızı gereksiz yere yorabilir.</p><p>İşte burada <strong>paralel programlama</strong> devreye giriyor! Bilgisayarın işlemci çekirdekleri (CPU) veya grafik işlemcisi (GPU) aynı anda pek çok işlemi yapabilir. Bu sayede yapay zeka modellerimizi daha hızlı ve verimli eğitebilir, sonuçları çok daha kısa sürede alabiliriz.</p><p>Bu yazıda Python’da <strong>CPU üzerinde paralel hesaplama</strong> yapmanın temelini atıyoruz. Örneğin, iki büyük listeyi toplamak gibi basit bir işlem bile, paralel yapılınca çok daha hızlı tamamlanabiliyor. Bu temel bilgileri kavradıktan sonra, daha karmaşık yapay zeka algoritmalarını hızlandırmak için GPU programlama gibi ileri tekniklere geçebiliriz.</p><p><strong>Paralel Programlamaya Giriş: CPU Üzerinde Python ile Basit Paralel Programlama</strong></p><p>Bilgisayarlarımızda işlemci (CPU) genellikle birden fazla çekirdeğe sahiptir. Eğer işlemlerimizi sadece tek bir çekirdekte seri (ardışık) olarak yaparsak, tüm işlem gücünün sadece bir kısmını kullanmış oluruz. Paralel programlama, işleri bu çekirdekler arasında bölerek hız kazanmamızı sağlar.</p><p>Python’da paralel programlama için en yaygın yöntemlerden biri multiprocessing modülüdür. Bu modül, her çekirdek için ayrı bir işlem (process) oluşturup işlemi bölerek aynı anda çalıştırmamızı sağlar. Böylece büyük veri setleri çok daha hızlı işlenebilir.</p><p>Python’da paralel programlama için birkaç yöntem vardır:</p><ul><li><strong>Threading:</strong> Çoklu iş parçacığı oluşturur, ancak Python’un GIL (Global Interpreter Lock) nedeniyle CPU yoğun işlemlerde tam paralellik sağlayamaz.</li><li><strong>Multiprocessing:</strong> Her çekirdek için ayrı Python işlemcisi başlatır, bu sayede gerçek paralel işlem yapılır.</li></ul><p>Biz bu örnekte multiprocessing modülünü kullanacağız.</p><p><strong>Monte Carlo Yöntemi ile Pi Sayısının Tahmini — CPU Üzerinde Seri ve Paralel Hesaplama</strong></p><p><strong>Monte Carlo Yöntemi Nedir?</strong><br> Monte Carlo yöntemi, rastgele örneklemeye dayanan bir istatistiksel hesaplama yöntemidir. Pi sayısının tahmini için birim kare içine çizilen birim çemberin alan oranı kullanılır. Rastgele nokta üretilip, bu noktaların çemberin içinde kalma oranı hesaplanarak pi değeri tahmin edilir.</p><p><strong>Kodun İşleyişi:</strong></p><ul><li>monte_carlo_pi_part fonksiyonu, belirli sayıda rastgele nokta üretir ve bu noktaların kaçının çemberin içinde kaldığını sayar.</li><li>Önce, <strong>seri hesaplama</strong> yapılır: Tüm örnekler tek bir işlemci çekirdeği üzerinde ardışık olarak hesaplanır.</li><li>Ardından, <strong>paralel hesaplama</strong> gerçekleştirilir: Örnekler işlemci çekirdek sayısına bölünür ve her çekirdek ayrı bir işlemde bağımsız olarak çalışır. Sonuçlar toplanarak toplam tahmin elde edilir.</li></ul><p><strong>Amaç ve Önemi:</strong></p><ul><li>Bu örnek, paralel programlamanın <strong>CPU’nun çok çekirdekli yapısını etkin şekilde kullanarak hesaplama süresini nasıl kısaltabileceğini</strong> somut şekilde göstermektedir.</li><li>Paralel programlama, büyük ve tekrarlayan hesaplamaların süresini azaltarak daha hızlı sonuç alınmasını sağlar.</li><li>Böylece, hem teoride paralel programlama kavramı hem de pratikte performans kazanımı somutlaştırılmış olur.</li></ul><p>Şimdi de kodu inceleyelim:</p><pre>import multiprocessing<br>import random<br>import time</pre><p>Paralel programlama için Python’un multiprocessing modülünü, rastgele sayı üretimi için random modülünü ve süre ölçmek için time modülünü içe aktarıyoruz.</p><pre>def monte_carlo_pi_part(samples):<br>    count = 0<br>    for _ in range(samples):<br>        x, y = random.random(), random.random()<br>        if x*x + y*y &lt;= 1:<br>            count += 1<br>    return count</pre><ul><li>monte_carlo_pi_part fonksiyonu, verilen samples sayısı kadar rastgele (x, y) koordinatı üretir.</li><li>Bu noktaların birim kare içinde olup olmadığını kontrol ederiz; çemberin içinde ise count artırılır.</li><li>Fonksiyon, çember içinde kalan nokta sayısını döndürür.</li></ul><pre>if __name__ == &quot;__main__&quot;:<br>    total_samples = 100_000_000<br>    cpu_count = multiprocessing.cpu_count()<br>    samples_per_process = total_samples // cpu_count</pre><ul><li>total_samples: Toplam örnek sayısı, yani rastgele nokta sayısı (100 milyon).</li><li>cpu_count: Bilgisayardaki işlemci çekirdeği sayısı alınır.</li><li>samples_per_process: Her paralel işlem için düşen örnek sayısı hesaplanır.</li></ul><pre>start = time.time()<br># Seri hesaplama<br>count_serial = monte_carlo_pi_part(total_samples)<br>pi_serial = 4 * count_serial / total_samples<br>end = time.time()<br>serial_time = end-start<br>print(f&quot;Seri Pi tahmini: {pi_serial}, süre: {serial_time} saniye&quot;)</pre><ul><li>Tüm örnekler tek bir işlemde (seride) hesaplanır.</li><li>Çember içindeki nokta oranından pi tahmini yapılır.</li><li>İşlem süresi hesaplanıp ekrana yazdırılır.</li></ul><pre>start = time.time()<br># Paralel hesaplama<br>with multiprocessing.Pool(cpu_count) as pool:<br>    results = pool.map(monte_carlo_pi_part, [samples_per_process]*cpu_count)<br>count_parallel = sum(results)<br>pi_parallel = 4 * count_parallel / total_samples<br>end = time.time()<br>parallel_time = end-start<br>print(f&quot;Paralel Pi tahmini: {pi_parallel}, süre: {parallel_time} saniye&quot;)</pre><ul><li>İşlemci çekirdeği sayısı kadar işlem havuzu (Pool) oluşturulur.</li><li>Her işlem havuzu elemanına eşit sayıda örnek hesaplaması gönderilir.</li><li>Paralel olarak her işlem bağımsız şekilde monte_carlo_pi_part fonksiyonunu çalıştırır.</li><li>Sonuçlar toplanır, toplam çember içi nokta sayısı hesaplanır.</li><li>Pi tahmini yapılır ve paralel hesaplama süresi ekrana yazdırılır.</li></ul><p>Kodun çıktısına bakarsak:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/688/1*5jVKX2Pqhlq9bdOt88K7Aw.png" /></figure><p>Bir de aldığımız sonuçları görselleştirip grafik üzerinden incelersek:</p><pre>    labels = [&#39;Seri&#39;, &#39;Paralel&#39;]<br>    times = [serial_time, parallel_time]<br><br>    plt.bar(labels, times, color=[&#39;blue&#39;, &#39;green&#39;])<br>    plt.ylabel(&#39;Süre (saniye)&#39;)<br>    plt.title(&#39;Seri ve Paralel Monte Carlo Pi Tahmini Süre Karşılaştırması&#39;)<br><br>    for i, v in enumerate(times):<br>        plt.text(i, v + 0.2, f&quot;{v:.2f}&quot;, ha=&#39;center&#39;, fontweight=&#39;bold&#39;)<br><br>    plt.show()</pre><p>Burada da çıktısını görebiliriz:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/784/1*MuaoMBN6VL32NDzxhvG81g.png" /></figure><p><strong>Özet</strong></p><ul><li>Seri hesaplama <strong>tek çekirdekte</strong> tüm örnekleri ardışık olarak işliyor.</li><li>Paralel hesaplama ise örnekleri <strong>birden fazla çekirdeğe dağıtarak eşzamanlı</strong> çalıştırıyor ve böylece süreyi kısaltıyor.</li><li>Bu örnek, çok çekirdekli CPU’ları verimli kullanarak işlem süresini azaltmanın somut bir yolunu gösteriyor.</li></ul><p>Bu yazıda, CPU üzerinde hem <strong>seri</strong> hem de <strong>paralel programlama</strong> yaklaşımlarını örneklerle gördük ve temel farklarını inceledik. Paralel programlama sayesinde çok çekirdekli işlemcilerin gücünü kullanarak, büyük hesaplamaları çok daha kısa sürede tamamlayabileceğimizi gözlemledik. Ancak, paralel programlama da kendi zorluklarını ve dikkat edilmesi gereken noktaları beraberinde getirir.</p><p>Bir sonraki adımlarımızda paralel programlamayı derinleştirerek;</p><ul><li><strong>İş parçalama (task decomposition)</strong> ve iş yükünün verimli bölünmesi,</li><li>Paralel çalışan işlemler arasında <strong>veri paylaşımı ve senkronizasyon</strong> teknikleri,</li><li>Python’da <strong>thread ve process</strong> farkları, özellikle <strong>GIL (Global Interpreter Lock)</strong> konusunun derinlemesine anlaşılması,</li><li>Paralel kodun performansını analiz etmek için <strong>profiling (cProfile, timeit)</strong> araçlarının kullanımı,</li><li>Ve farklı Python paralel kütüphaneleri (<strong>concurrent.futures</strong>, <strong>joblib</strong> gibi) ile farklı yaklaşımların denenmesi</li></ul><p>gibi konuları detaylıca ele alacağız.</p><p>Ayrıca, <strong>GPU programlama</strong> alanına geçiş yaparak grafik işlemcilerin paralel hesaplama gücünü nasıl kullanabileceğimizi öğreneceğiz. Bu sayede, yüksek performanslı algoritmalar geliştirerek gerçek dünyadaki büyük veri ve yapay zeka problemlerine etkili çözümler sunabileceğiz.</p><p>Okuduğun için teşekkür ederim Umarım işine yaramıştır ve aklında bir cümle de olsa yer edinebilmiştir. Bir sonraki yazıda görüşmek üzere!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9fd3fd56b476" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>