.. _sec_information_theory: Bilgi Teorisi ============= Evren bilgi ile dolup taşıyor. Bilgi, disiplinler arası açıklıklarda ortak bir dil sağlar: Shakespeare'in Sone'sinden Cornell ArXiv'deki araştırmacıların makalesine, Van Gogh'un eseri Yıldızlı Gece'den Beethoven'in 5. Senfonisi'ne, ilk programlama dili Plankalkül'den son teknoloji makine öğrenmesi algoritmalarına. Biçimi ne olursa olsun, her şey bilgi teorisinin kurallarını izlemelidir. Bilgi teorisi ile, farklı sinyallerde ne kadar bilgi bulunduğunu ölçebilir ve karşılaştırabiliriz. Bu bölümde, bilgi teorisinin temel kavramlarını ve bilgi teorisinin makine öğrenmesindeki uygulamalarını inceleyeceğiz. Başlamadan önce, makine öğrenmesi ve bilgi teorisi arasındaki ilişkiyi özetleyelim. Makine öğrenmesi, verilerden ilginç sinyaller çıkarmayı ve kritik tahminlerde bulunmayı amaçlar. Öte yandan, bilgi teorisi, bilgiyi kodlama, kod çözme, iletme ve üstünde oynama yapmayı inceler. Sonuç olarak, bilgi teorisi, makine öğrenmesi sistemlerinde bilgi işlemeyi tartışmak için temel bir dil sağlar. Örneğin, birçok makine öğrenmesi uygulaması çapraz entropi kaybını şurada açıklandığı gibi kullanır :numref:`sec_softmax`. Bu kayıp, doğrudan bilgi teorisel değerlendirmelerinden türetilebilir. Bilgi ----- Bilgi teorisinin "ruhu" ile başlayalım: Bilgi. *Bilgi*, bir veya daha fazla kodlama biçimli belirli bir dizi ile kodlanabilir. Kendimizi bir bilgi kavramını tanımlamaya çalışmakla görevlendirdiğimizi varsayalım. Başlangıç ​​noktamız ne olabilir? Aşağıdaki düşünce deneyini düşünün. Kart destesi olan bir arkadaşımız var. Desteyi karıştıracaklar, bazı kartları ters çevirecekler ve bize kartlar hakkında açıklamalar yapacaklar. Her ifadenin bilgi içeriğini değerlendirmeye çalışacağız. Önce, bir kartı çevirip bize "Bir kart görüyorum" diyorlar. Bu bize hiçbir bilgi sağlamaz. Durumun bu olduğundan zaten emindik, bu yüzden bilginin sıfır olduğu umuyoruz. Sonra bir kartı çevirip "Bir kalp görüyorum" diyorlar. Bu bize biraz bilgi sağlar, ancak gerçekte, her biri eşit olasılıkla mümkün olan yalnızca :math:`4` farklı takım vardır, bu nedenle bu sonuca şaşırmadık. Bilginin ölçüsü ne olursa olsun, bu olayın düşük bilgi içeriğine sahip olmasını umuyoruz. Sonra, bir kartı çevirip "Bu maça :math:`3`" diyorlar. Bu daha fazla bilgidir. Gerçekten de :math:`52` eşit olasılıklı sonuçlar vardı ve arkadaşımız bize bunun hangisi olduğunu söyledi. Bu orta miktarda bilgi olmalıdır. Bunu mantıksal uç noktaya götürelim. Sonunda destedeki her kartı çevirdiklerini ve karışık destenin tüm dizisini okuduklarını varsayalım. Destede :math:`52!` farklı dizilim var, gene hepsi aynı olasılığa sahip, bu yüzden hangisinin olduğunu bilmek için çok fazla bilgiye ihtiyacımız var. Geliştirdiğimiz herhangi bir bilgi kavramı bu sezgiye uygun olmalıdır. Aslında, sonraki bölümlerde bu olayların :math:`0\text{ bit}`, :math:`2\text{ bit}`, :math:`~5.7\text{ bit}`, and :math:`~225.6\text{ bit}` bilgiye sahip olduğunu nasıl hesaplayacağımızı öğreneceğiz. Bu düşünce deneylerini okursak, doğal bir fikir görürüz. Başlangıç noktası olarak, bilgiyi önemsemekten ziyade, bilginin olayın sürpriz derecesini veya soyut olasılığını temsil ettiği fikrini geliştirebiliriz. Örneğin, alışılmadık bir olayı tanımlamak istiyorsak, çok fazla bilgiye ihtiyacımız var. Genel (sıradan) bir olay için fazla bilgiye ihtiyacımız olmayabilir. 1948'de Claude E. Shannon bilgi teorisini oluşturan *İletişimin Bir Matematiksel Teorisi (A Mathematical Theory of Communication)* çalışmasını yayınladı :cite:`Shannon.1948`. Shannon makalesinde ilk kez bilgi entropisi kavramını tanıttı. Yolculuğumuza buradan başlayacağız. Öz-Bilgi ~~~~~~~~ Bilgi bir olayın soyut olasılığını içerdiğinden, olasılığı bit adeti ile nasıl eşleştirebiliriz? Shannon, başlangıçta John Tukey tarafından oluşturulmuş olan *bit* terimini bilgi birimi olarak tanıttı. Öyleyse "bit" nedir ve bilgiyi ölçmek için neden onu kullanıyoruz? Tarihsel olarak, antika bir verici yalnızca iki tür kod gönderebilir veya alabilir: :math:`0` ve :math:`1`. Aslında, ikili kodlama hala tüm modern dijital bilgisayarlarda yaygın olarak kullanılmaktadır. Bu şekilde, herhangi bir bilgi bir dizi :math:`0` ve :math:`1` ile kodlanır. Ve bu nedenle, :math:`n` uzunluğundaki bir dizi ikili rakam, :math:`n` bit bilgi içerir. Şimdi, herhangi bir kod dizisi için, her :math:`0` veya :math:`1`'in :math:`\frac{1}{2}` olasılıkla gerçekleştiğini varsayalım. Bu nedenle, :math:`n` uzunluğunda bir dizi koda sahip bir :math:`X` olayı, :math:`\frac{1}{2^n}` olasılıkla gerçekleşir. Aynı zamanda, daha önce bahsettiğimiz gibi, bu seri :math:`n` bit bilgi içerir. Öyleyse, :math:`p` olasılığını bit sayısına aktarabilen bir matematik fonksiyonuna genelleme yapabilir miyiz? Shannon, *öz-bilgi*\ yi tanımlayarak cevabı verdi, .. math:: I(X) = - \log_2 (p), yani bu :math:`X` etkinliği için aldığımız bilginin *bitleri* olarak. Bu bölümde her zaman 2 tabanlı logaritma kullanacağımızı unutmayın. Basitlik adına, bu bölümün geri kalanı logaritma gösteriminde 2 altindisini göstermeyecektir, yani :math:`\log(.)` her zaman :math:`\log_2(.)` anlamına gelir. Örneğin, "0010" kodu şu öz-bilgiyi içerir: .. math:: I(\text{"0010"}) = - \log (p(\text{"0010"})) = - \log \left( \frac{1}{2^4} \right) = 4 \text{ bits}. Öz-bilgiyi aşağıda gösterildiği gibi hesaplayabiliriz. Ondan önce, önce bu bölümdeki gerekli tüm paketleri içe aktaralım. .. raw:: html
mxnetpytorchtensorflow
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python import random from mxnet import np from mxnet.metric import NegativeLogLikelihood from mxnet.ndarray import nansum def self_information(p): return -np.log2(p) self_information(1 / 64) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output 6.0 .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python import torch from torch.nn import NLLLoss def nansum(x): # Define nansum, as pytorch doesn't offer it inbuilt. return x[~torch.isnan(x)].sum() def self_information(p): return -torch.log2(torch.tensor(p)).item() self_information(1 / 64) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output 6.0 .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python import tensorflow as tf def log2(x): return tf.math.log(x) / tf.math.log(2.) def nansum(x): return tf.reduce_sum(tf.where(tf.math.is_nan( x), tf.zeros_like(x), x), axis=-1) def self_information(p): return -log2(tf.constant(p)).numpy() self_information(1 / 64) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output 6.0 .. raw:: html
.. raw:: html
Entropi ------- Öz-bilgi yalnızca tek bir ayrık olayın bilgisini ölçtüğü için, ayrık veya sürekli dağılımın herhangi bir rastgele değişkeni için daha genelleştirilmiş bir ölçüme ihtiyacımız var. Motive Edici Entropi ~~~~~~~~~~~~~~~~~~~~ Ne istediğimiz konusunda belirli olmaya çalışalım. Bu, *Shannon entropisinin aksiyomları* olarak bilinenlerin gayri resmi bir ifadesi olacaktır. Aşağıdaki sağduyu beyanları topluluğunun bizi benzersiz bir bilgi tanımına zorladığı ortaya çıkacaktır. Bu aksiyomların usule uygun bir versiyonu, diğer birçoklarıyla birlikte şu adreste bulunabilir :cite:`Csiszar.2008`. 1. Rastgele bir değişkeni gözlemleyerek kazandığımız bilgi, elemanlar dediğimiz şeye veya olasılığı sıfır olan ek elemanların varlığına bağlı değildir. 2. İki rastgele değişkeni gözlemleyerek elde ettiğimiz bilgi, onları ayrı ayrı gözlemleyerek elde ettiğimiz bilgilerin toplamından fazlası değildir. Bağımsız iseler, o zaman tam toplamdır. 3. (Neredeyse) Kesin olayları gözlemlerken kazanılan bilgi (neredeyse) sıfırdır. Bu gerçeğin kanıtlanması kitabımızın kapsamı dışında olduğu halde, bunun entropinin alması gereken şekli benzersiz bir şekilde belirlediğini bilmek önemlidir. Bunların izin verdiği tek belirsizlik, daha önce gördüğümüz seçimi yaparak normalize edilen temel birimlerin seçimidir; tek bir adil yazı tura ile sağlanan bilginin bir bit olması gibi. Tanım ~~~~~ Olasılık yoğunluk fonksiyonu (pdf/oyf) veya olasılık kütle fonksiyonu (pmf/okf) :math:`p(x)` ile olasılık dağılımı :math:`P`'yi takip eden rastgele değişken :math:`X` için, beklenen bilgi miktarını *entropi* (veya *Shannon entropisi*) ile ölçebiliriz: .. math:: H(X) = - E_{x \sim P} [\log p(x)]. :label: eq_ent_def Belirleyici olmak gerekirse, :math:`X` ayrıksa, .. math:: H(X)= - \sum_i p_i \log p_i \text{, burada } p_i = P(X_i) . Aksi takdirde, :math:`X` sürekli ise, entropiyi *diferansiyel (farksal) entropi* olarak da adlandırırız. .. math:: H(X) = - \int_x p(x) \log p(x) \; dx. Entropiyi aşağıdaki gibi tanımlayabiliriz. .. raw:: html
mxnetpytorchtensorflow
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def entropy(p): entropy = - p * np.log2(p) # `nansum` işlemcisi, nan (not a number - sayı olmayan) olmayan sayıyı toplayacaktır out = nansum(entropy.as_nd_ndarray()) return out entropy(np.array([0.1, 0.5, 0.1, 0.3])) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output [1.6854753] .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def entropy(p): entropy = - p * torch.log2(p) # `nansum` işlemcisi, nan (not a number - sayı olmayan) olmayan sayıyı toplayacaktır out = nansum(entropy) return out entropy(torch.tensor([0.1, 0.5, 0.1, 0.3])) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output tensor(1.6855) .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def entropy(p): return nansum(- p * log2(p)) entropy(tf.constant([0.1, 0.5, 0.1, 0.3])) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output .. raw:: html
.. raw:: html
Yorumlama ~~~~~~~~~ Merak ediyor olabilirsiniz: Entropi tanımında :eq:`eq_ent_def`, neden negatif bir logaritma ortalaması kullanıyoruz? Burada bazı sezgileri verelim. İlk olarak, neden *logaritma* işlevi :math:`\log` kullanıyoruz? :math:`p(x) = f_1(x) f_2(x) \ldots, f_n(x)` olduğunu varsayalım, burada her bileşen işlevi :math:`f_i(x)` birbirinden bağımsızdır. Bu, her bir :math:`f_i(x)`'in :math:`p(x)`'den elde edilen toplam bilgiye bağımsız olarak katkıda bulunduğu anlamına gelir. Yukarıda tartışıldığı gibi, entropi formülünün bağımsız rastgele değişkenler üzerinde toplamsal olmasını istiyoruz. Neyse ki, :math:`\log` doğal olarak olasılık dağılımlarının çarpımını bireysel terimlerin toplamına dönüştürebilir. Sonra, neden *negatif* :math:`\log` kullanıyoruz? Sezgisel olarak, alışılmadık bir vakadan genellikle sıradan olandan daha fazla bilgi aldığımız için, daha sık olaylar, daha az yaygın olaylardan daha az bilgi içermelidir. Bununla birlikte, :math:`\log` olasılıklarla birlikte monoton bir şekilde artıyor ve aslında :math:`[0, 1]` içindeki tüm değerler için negatif. Olayların olasılığı ile entropileri arasında monoton olarak azalan bir ilişki kurmamız gerekir ki bu ideal olarak her zaman pozitif olacaktır (çünkü gözlemlediğimiz hiçbir şey bizi bildiklerimizi unutmaya zorlamamalıdır). Bu nedenle, :math:`\log` fonksiyonunun önüne bir eksi işareti ekliyoruz. Son olarak, *beklenti (ortalama)* işlevi nereden geliyor? Rastgele bir değişken olan :math:`X'i` düşünün. Öz-bilgiyi (:math:`-\log(p)`), belirli bir sonucu gördüğümüzde sahip olduğumuz *sürpriz* miktarı olarak yorumlayabiliriz. Nitekim, olasılık sıfıra yaklaştıkça sürpriz sonsuz olur. Benzer şekilde, entropiyi :math:`X`'i gözlemlemekten kaynaklanan ortalama sürpriz miktarı olarak yorumlayabiliriz. Örneğin, bir slot makinesi sisteminin :math:`{p_1, \ldots, p_k}` olasılıklarıyla :math:`{s_1, \ldots, s_k}` sembollerini istatistiksel olarak bağımsız yaydığını düşünün. O zaman bu sistemin entropisi, her bir çıktının gözlemlenmesinden elde edilen ortalama öz-bilgiye eşittir, yani, .. math:: H(S) = \sum_i {p_i \cdot I(s_i)} = - \sum_i {p_i \cdot \log p_i}. Entropinin Özellikleri ~~~~~~~~~~~~~~~~~~~~~~ Yukarıdaki örnekler ve yorumlarla, entropinin :eq:`eq_ent_def` şu özelliklerini türetebiliriz. Burada, :math:`X`'i bir olay ve :math:`P`'yi :math:`X`'in olasılık dağılımı olarak adlandırıyoruz. - Tüm ayrık :math:`X` değerleri için :math:`H(X) \geq 0`'dır (sürekli :math:`X` için entropi negatif olabilir). - Bir o.y.f veya o.k.f. :math:`p(x)` ile :math:`X \sim P` ise ve o.y.f veya o.k.f. :math:`q(x)`'ya sahip yeni bir olasılık dağılımı :math:`Q` ile :math:`P`'yi tahmin etmeye çalışıyoruz, o zaman .. math:: H(X) = - E_{x \sim P} [\log p(x)] \leq - E_{x \sim P} [\log q(x)], \text {eşitlikle ancak ve ancak eğer } P = Q. Alternatif olarak, :math:`H(X)`, :math:`P`'den çekilen sembolleri kodlamak için gereken ortalama bit sayısının alt sınırını verir. - :math:`X \sim P` ise, :math:`x` tüm olası sonuçlar arasında eşit olarak yayılırsa maksimum bilgi miktarını iletir. Özel olarak, :math:`P` :math:`k`-sınıflı ayrık olasılık dağılımı :math:`\{p_1, \ldots, p_k \}` ise, o halde .. math:: H(X) \leq \log(k), \text {eşitlikle ancak ve ancak eğer } p_i = \frac{1}{k}, \forall i. Eğer :math:`P` sürekli bir rastgele değişkense, öykü çok daha karmaşık hale gelir. Bununla birlikte, ek olarak :math:`P`'nin sonlu bir aralıkta (tüm değerler :math:`0` ile :math:`1` arasında) desteklenmesini zorlarsak, bu aralıkta tekdüze dağılım varsa :math:`P` en yüksek entropiye sahip olur. Ortak Bilgi ----------- Daha önce tek bir rastgele değişken :math:`X` entropisini tanımlamıştık, bir çift rastgele değişken :math:`(X, Y)` entropisine ne dersiniz? Bu teknikleri şu soru tipini yanıtlamaya çalışırken düşünebiliriz: ":math:`X` ve :math:`Y`'de her biri ayrı ayrı olması bir arada olmalarıyla karşılaştırıldığında ne tür bilgi bulunur? Gereksiz bilgi var mı, yoksa hepsi eşsiz mi?" Aşağıdaki tartışma için, her zaman :math:`(X, Y)`'yi, bir o.y.f veya o.k.f. olan :math:`p_{X, Y}(x, y)` ile bileşik olasılık dağılımı :math:`P`'yi izleyen bir çift rastgele değişken olarak kullanıyoruz, aynı zamanda da :math:`X` ve :math:`Y` sırasıyla :math:`p_X(x)` ve :math:`p_Y(y)` olasılık dağılımlarını takip eder. Bileşik Entropi ~~~~~~~~~~~~~~~ Tek bir rastgele değişkenin entropisine benzer şekilde :eq:`eq_ent_def`, rastgele değişken çiftinin, :math:`(X, Y)`, *bileşik entropisini* :math:`H (X, Y)` olarak tanımlarız. .. math:: H(X, Y) = −E_{(x, y) \sim P} [\log p_{X, Y}(x, y)]. :label: eq_joint_ent_def Tam olarak, bir yandan :math:`(X, Y)` bir çift ayrık rastgele değişkense, o zaman .. math:: H(X, Y) = - \sum_{x} \sum_{y} p_{X, Y}(x, y) \log p_{X, Y}(x, y). Öte yandan, :math:`(X, Y)` bir çift sürekli rastgele değişken ise, o zaman *diferansiyel (farksal) bileşik entropiyi* tanımlarız. .. math:: H(X, Y) = - \int_{x, y} p_{X, Y}(x, y) \ \log p_{X, Y}(x, y) \;dx \;dy. Şunu düşünebiliriz :eq:`eq_joint_ent_def` bize rastgele değişkenler çiftindeki toplam rastgeleliği anlatıyor. Bir çift uç vaka olarak, eğer :math:`X = Y` iki özdeş rastgele değişken ise, o zaman çiftteki bilgi tam olarak bir tanedeki bilgidir ve :math:`H(X, Y) = H(X) = H(Y)`'dir. Diğer uçta, :math:`X` ve :math:`Y` bağımsızsa, :math:`H(X, Y) = H(X) + H(Y)`'dir. Aslında, her zaman bir çift rasgele değişkenin içerdiği bilginin her iki rasgele değişkenin entropisinden daha küçük ve her ikisinin toplamından daha fazla olmadığını bilecegiz. .. math:: H(X), H(Y) \le H(X, Y) \le H(X) + H(Y). Ortak entropiyi en başından uygulayalım. .. raw:: html
mxnetpytorchtensorflow
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def joint_entropy(p_xy): joint_ent = -p_xy * np.log2(p_xy) # `nansum` işlemcisi, nan (not a number - sayı olmayan) olmayan sayıyı toplayacaktır out = nansum(joint_ent.as_nd_ndarray()) return out joint_entropy(np.array([[0.1, 0.5], [0.1, 0.3]])) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output [1.6854753] .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def joint_entropy(p_xy): joint_ent = -p_xy * torch.log2(p_xy) # `nansum` işlemcisi, nan (not a number - sayı olmayan) olmayan sayıyı toplayacaktır out = nansum(joint_ent) return out joint_entropy(torch.tensor([[0.1, 0.5], [0.1, 0.3]])) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output tensor(1.6855) .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def joint_entropy(p_xy): joint_ent = -p_xy * log2(p_xy) # `nansum` işlemcisi, nan (not a number - sayı olmayan) olmayan sayıyı toplayacaktır out = nansum(joint_ent) return out joint_entropy(tf.constant([[0.1, 0.5], [0.1, 0.3]])) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output .. raw:: html
.. raw:: html
Bunun öncekiyle aynı *kod* olduğuna dikkat edin, ancak şimdi onu iki rastgele değişkenin bileşik dağılımı üzerinde çalışırken farklı bir şekilde yorumluyoruz. Koşullu Entropi ~~~~~~~~~~~~~~~ Bileşik entropi bir çift rastgele değişkende bulunan bilgi miktarının üzerinde tanımlıdır. Bu yararlıdır, ancak çoğu zaman umursadığımız şey değildir. Makine öğrenmesinin ayarlarını düşünün. Bir imgenin piksel değerlerini tanımlayan rastgele değişken (veya rastgele değişkenlerin vektörü) olarak :math:`X`'i ve sınıf etiketi olan rastgele değişken olarak :math:`Y`'yi alalım. :math:`X` önemli bilgi içermelidir --- doğal bir imge karmaşık bir şeydir. Ancak, imge gösterildikten sonra :math:`Y` içindeki bilgi düşük olmalıdır. Aslında, bir rakamın imgesi, rakam okunaksız olmadıkça, hangi rakam olduğu hakkında bilgiyi zaten içermelidir. Bu nedenle, bilgi teorisi kelime dağarcığımızı genişletmeye devam etmek için, rastgele bir değişkenin diğerine koşullu bağlı olarak bilgi içeriği hakkında mantık yürütebilmeliyiz. Olasılık teorisinde, değişkenler arasındaki ilişkiyi ölçmek için *koşullu olasılığın* tanımını gördük. Şimdi, *koşullu entropiyi*, :math:`H(Y \mid X)`, benzer şekilde tanımlamak istiyoruz. Bunu şu şekilde yazabiliriz: .. math:: H(Y \mid X) = - E_{(x, y) \sim P} [\log p(y \mid x)], :label: eq_cond_ent_def Burada :math:`p(y \mid x) = \frac{p_{X, Y}(x, y)}{p_X(x)}` koşullu olasılıktır. Özellikle, :math:`(X, Y)` bir çift ayrık rastgele değişken ise, o zaman .. math:: H(Y \mid X) = - \sum_{x} \sum_{y} p(x, y) \log p(y \mid x). :math:`(X, Y)` bir çift sürekli rastgele değişkense, *diferansiyel koşullu entropi* benzer şekilde şöyle tanımlanır: .. math:: H(Y \mid X) = - \int_x \int_y p(x, y) \ \log p(y \mid x) \;dx \;dy. Şimdi bunu sormak doğaldır, *koşullu entropi* :math:`H(Y \mid X)`, :math:`H(X)` entropisi ve bileşik entropi :math:`H(X, Y)` ile nasıl ilişkilidir? Yukarıdaki tanımları kullanarak bunu net bir şekilde ifade edebiliriz: .. math:: H(Y \mid X) = H(X, Y) - H(X). Bunun sezgisel bir yorumu vardır: :math:`X` verildiğinde (:math:`H(Y \mid X)`) :math:`Y`'deki bilgi, hem :math:`X` hem de :math:`Y` (:math:`H(X, Y)`) birlikteyken olan bilgi eksi :math:`X` içinde zaten bulunan bilgidir. Bu bize :math:`Y`'de olup da aynı zamanda :math:`X` ile temsil edilmeyen bilgiyi verir. Şimdi, koşullu entropiyi, :eq:`eq_cond_ent_def`, sıfırdan uygulayalım. .. raw:: html
mxnetpytorchtensorflow
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def conditional_entropy(p_xy, p_x): p_y_given_x = p_xy/p_x cond_ent = -p_xy * np.log2(p_y_given_x) # `nansum` işlemcisi, nan (not a number - sayı olmayan) olmayan sayıyı toplayacaktır out = nansum(cond_ent.as_nd_ndarray()) return out conditional_entropy(np.array([[0.1, 0.5], [0.2, 0.3]]), np.array([0.2, 0.8])) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output [0.8635472] .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def conditional_entropy(p_xy, p_x): p_y_given_x = p_xy/p_x cond_ent = -p_xy * torch.log2(p_y_given_x) # `nansum` işlemcisi, nan (not a number - sayı olmayan) olmayan sayıyı toplayacaktır out = nansum(cond_ent) return out conditional_entropy(torch.tensor([[0.1, 0.5], [0.2, 0.3]]), torch.tensor([0.2, 0.8])) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output tensor(0.8635) .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def conditional_entropy(p_xy, p_x): p_y_given_x = p_xy/p_x cond_ent = -p_xy * log2(p_y_given_x) # `nansum` işlemcisi, nan (not a number - sayı olmayan) olmayan sayıyı toplayacaktır out = nansum(cond_ent) return out conditional_entropy(tf.constant([[0.1, 0.5], [0.2, 0.3]]), tf.constant([0.2, 0.8])) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output .. raw:: html
.. raw:: html
Karşılıklı Bilgi ~~~~~~~~~~~~~~~~ Önceki rastgele değişkenler :math:`(X, Y)` ortamını göz önünde bulundurarak şunu merak edebilirsiniz: "Artık :math:`Y`'nin ne kadar bilgi içerdiğini ancak :math:`X`'de olmadığını bildiğimize göre, benzer şekilde :math:`X` ve :math:`Y`'nin aralarında ne kadar bilginin paylaşıldığını da sorabilir miyiz?" Cevap, :math:`(X, Y)`'nin *karşılıklı bilgisi* olacak ve bunu :math:`I(X, Y)` olarak yazacağız. Doğrudan biçimsel (formal) tanıma dalmak yerine, önce karşılıklı bilgi için tamamen daha önce oluşturduğumuz terimlere dayalı bir ifade türetmeyi deneyerek sezgilerimizi uygulayalım. İki rastgele değişken arasında paylaşılan bilgiyi bulmak istiyoruz. Bunu yapmaya çalışmanın bir yolu, hem :math:`X` hem de :math:`Y` içerisindeki tüm bilgi ile başlamak ve sonra paylaşılmayan kısımları çıkarmaktır. Hem :math:`X` hem de :math:`Y` içerisindeki bilgi, :math:`H(X, Y)` olarak yazılır. Bundan, :math:`X` içinde yer alan ama :math:`Y` içinde yer almayan bilgileri ve :math:`Y` içinde yer alan ama :math:`X` içinde olmayan bilgileri çıkarmak istiyoruz. Önceki bölümde gördüğümüz gibi, bu sırasıyla :math:`H(X \mid Y)` ve :math:`H(Y \mid X)` ile verilmektedir. Bu nedenle, karşılıklı bilginin şöyle olması gerek: .. math:: I(X, Y) = H(X, Y) - H(Y \mid X) − H(X \mid Y). Aslında bu, karşılıklı bilgi için geçerli bir tanımdır. Bu terimlerin tanımlarını genişletir ve bunları birleştirirsek, biraz cebir bunun aşağısı gibi olduğunu gösterir .. math:: I(X, Y) = E_{x} E_{y} \left\{ p_{X, Y}(x, y) \log\frac{p_{X, Y}(x, y)}{p_X(x) p_Y(y)} \right\}. :label: eq_mut_ent_def Tüm bu ilişkileri görsel :numref:`fig_mutual_information` içinde özetleyebiliriz. Aşağıdaki ifadelerin de neden :math:`I(X, Y)` ile eşdeğer olduğunu görmek harika bir sezgi testidir. - :math:`H(X) − H(X \mid Y)` - :math:`H(Y) − H(Y \mid X)` - :math:`H(X) + H(Y) − H(X, Y)` .. _fig_mutual_information: .. figure:: ../img/mutual-information.svg Karşılıklı bilginin bileşik entropi ve koşullu entropi ile ilişkisi. Karşılıklı bilgiyi :eq:`eq_mut_ent_def` birçok yönden :numref:`sec_random_variables` içinde gördüğümüz korelasyon katsayısının ilkesel uzantısı olarak düşünebiliriz. Bu, yalnızca değişkenler arasındaki doğrusal ilişkileri değil, aynı zamanda herhangi bir türdeki iki rastgele değişken arasında paylaşılan maksimum bilgiyi de sorabilmemize olanak tanır. Şimdi karşılıklı bilgiyi sıfırdan uygulayalım. .. raw:: html
mxnetpytorchtensorflow
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def mutual_information(p_xy, p_x, p_y): p = p_xy / (p_x * p_y) mutual = p_xy * np.log2(p) # `nansum` işlemcisi, nan (not a number - sayı olmayan) olmayan sayıyı toplayacaktır out = nansum(mutual.as_nd_ndarray()) return out mutual_information(np.array([[0.1, 0.5], [0.1, 0.3]]), np.array([0.2, 0.8]), np.array([[0.75, 0.25]])) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output [0.7194603] .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def mutual_information(p_xy, p_x, p_y): p = p_xy / (p_x * p_y) mutual = p_xy * torch.log2(p) # `nansum` işlemcisi, nan (not a number - sayı olmayan) olmayan sayıyı toplayacaktır out = nansum(mutual) return out mutual_information(torch.tensor([[0.1, 0.5], [0.1, 0.3]]), torch.tensor([0.2, 0.8]), torch.tensor([[0.75, 0.25]])) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output tensor(0.7195) .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def mutual_information(p_xy, p_x, p_y): p = p_xy / (p_x * p_y) mutual = p_xy * log2(p) # `nansum` işlemcisi, nan (not a number - sayı olmayan) olmayan sayıyı toplayacaktır out = nansum(mutual) return out mutual_information(tf.constant([[0.1, 0.5], [0.1, 0.3]]), tf.constant([0.2, 0.8]), tf.constant([[0.75, 0.25]])) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output .. raw:: html
.. raw:: html
Karşılıklı Bilginin Özellikleri ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Karşılıklı bilginin tanımını, :eq:`eq_mut_ent_def`, ezberlemek yerine sadece dikkate değer özelliklerini aklınızda tutmanız gerekir: - Karşılıklı bilgi simetriktir (bakışımlı), yani :math:`I(X, Y) = I(Y, X)`. - Karşılıklı bilgi negatif olamaz, yani :math:`I(X, Y) \geq 0`. - :math:`I(X, Y) = 0` ancak ve ancak :math:`X` ve :math:`Y` bağımsızsa olur. Örneğin, :math:`X` ve :math:`Y` bağımsızsa, :math:`Y`'yi bilmek :math:`X` hakkında herhangi bir bilgi vermez ve bunun tersi de geçerlidir, dolayısıyla karşılıklı bilgileri sıfırdır. - Alternatif olarak, :math:`X`, :math:`Y` değerinin ters çevrilebilir bir işleviyse, :math:`Y` ve :math:`X` tüm bilgiyi paylaşır ve .. math:: I(X, Y) = H(Y) = H(X) . Noktasal Karşılıklı Bilgi ~~~~~~~~~~~~~~~~~~~~~~~~~ Bu bölümün başında entropi ile çalıştığımızda, :math:`-\log (p_X(x))`'i belirli bir sonuca ne kadar *şaşırdığımızın* yorumlanması diye sunabildik. Karşılıklı bilgideki logaritmik terime benzer bir yorum verebiliriz, bu genellikle *noktasal karşılıklı bilgi (pointwise mutual information - pmi)* olarak anılır: .. math:: \mathrm{pmi}(x, y) = \log\frac{p_{X, Y}(x, y)}{p_X(x) p_Y(y)}. :label: eq_pmi_def :eq:`eq_pmi_def` denklemi, bağımsız rastgele sonuçlar için beklentimizle karşılaştırıldığında :math:`x` ve :math:`y` sonuçlarının belirli kombinasyonunun ne kadar daha fazla veya daha az olası olduğunu ölçmek olarak düşünebiliriz. Büyük ve pozitifse, bu iki belirli sonuç, rastgele şansa kıyasla çok daha sık meydana gelir (*dikkat*: Payda :math:`p_X(x) p_Y(y)`'dir ki bu iki sonucun bağımsız olma olasılığıdır), bilakis büyük ve negatifse, şans eseri beklediğimizden çok daha az gerçekleşen iki sonucu temsil eder. Bu, karşılıklı bilgiyi, :eqref: ``eq_mut_ent_def``, bağımsız olsalardı bekleyeceğimiz şeyle karşılaştırıldığında iki sonucun birlikte gerçekleştiğini gördüğümüzde şaşırmamızın ortalama miktarı olarak yorumlamamıza olanak tanır. Karşılıklı Bilginin Uygulamaları ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Karşılıklı bilgi, saf tanımında biraz soyut olabilir, peki makine öğrenmesi ile nasıl ilişkilidir? Doğal dil işlemede, en zor sorunlardan biri *belirsizlik çözümü* yani bir kelimenin anlamının bağlamdan anlaşılmaz olması sorunudur. Örneğin son zamanlarda bir haber manşetinde "Amazon yanıyor" yazıyordu. Amazon şirketinin bir binası yanıyor mu, yoksa Amazon yağmur ormanı mı yanıyor diye merak edebilirsiniz. Bu durumda, karşılıklı bilgi bu belirsizliği çözmemize yardımcı olabilir. İlk olarak, e-ticaret, teknoloji ve çevrimiçi gibi, her birinin Amazon şirketi ile nispeten büyük karşılıklı bilgiye sahip olduğu kelime grubunu buluruz. İkinci olarak, her biri yağmur, orman ve tropikal gibi Amazon yağmur ormanlarıyla ilgili nispeten büyük karşılıklı bilgiye sahip başka bir kelime grubu buluruz. "Amazon"'un belirsizliğini ortadan kaldırmamız gerektiğinde, hangi grubun Amazon kelimesi bağlamında daha fazla yer aldığını karşılaştırabiliriz. Bu durumda haber ormanı tarif etmeye ve bağlamı netleştirmeye devam edecektir. Kullback–Leibler Iraksaması --------------------------- :numref:`sec_linear-algebra` içinde tartıştığımız gibi, herhangi bir boyutluluğun uzaydaki iki nokta arasındaki mesafeyi ölçmek için normları kullanabiliriz. Olasılık dağılımları ile de benzer bir iş yapabilmek istiyoruz. Bunu yapmanın birçok yolu var, ancak bilgi teorisi en güzellerinden birini sağlıyor. Şimdi, iki dağılımın birbirine yakın olup olmadığını ölçmenin bir yolunu sağlayan *Kullback–Leibler (KL) ıraksamasını* inceleyeceğiz. Tanım ~~~~~ Olasılık dağılımı bir o.y.f veya o.k.f. olan :math:`p(x)` ile izleyen rastgele bir değişken :math:`X` verildiğinde, o.y.f veya o.k.f.'u :math:`q(x)` olan başka bir olasılık dağılımı :math:`Q` kullanarak :math:`P`'yi tahmin ediyoruz. Böylece, :math:`P` ile :math:`Q` arasındaki *Kullback–Leibler (KL) ıraksaması* (veya *göreceli entropi*) hesaplanabilir: .. math:: D_{\mathrm{KL}}(P\|Q) = E_{x \sim P} \left[ \log \frac{p(x)}{q(x)} \right]. :label: eq_kl_def Noktasal karşılıklı bilgide olduğu gibi :eq:`eq_pmi_def`, logaritmik terimin yorumunu tekrar sağlayabiliriz: :math:`-\log \frac{q(x)}{p(x)} = -\log(q(x)) - (-\log(p(x)))`, :math:`x`'i :math:`P`'nın altında, :math:`Q`'da beklediğimizden çok daha fazla görürsek büyük ve pozitif, ve beklenenden çok daha az görürsek büyük ve negatif olacaktır. Bu şekilde, sonucu onu referans dağılımımızdan gözlemlememize oranla burada gözlemlediğimizde ne kadar şaşıracağımız, yani *göreceli* şaşkınlığımız, olarak yorumlayabiliriz. Sıfırdan KL ıraksamasını uygulayalım. .. raw:: html
mxnetpytorchtensorflow
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def kl_divergence(p, q): kl = p * np.log2(p / q) out = nansum(kl.as_nd_ndarray()) return out.abs().asscalar() .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def kl_divergence(p, q): kl = p * torch.log2(p / q) out = nansum(kl) return out.abs().item() .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def kl_divergence(p, q): kl = p * log2(p / q) out = nansum(kl) return tf.abs(out).numpy() .. raw:: html
.. raw:: html
KL Iraksamasının Özellikleri ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ KL ıraksamasının bazı özelliklerine bir göz atalım :eq:`eq_kl_def`. - KL ıraksaması simetrik değildir, yani .. math:: D_{\mathrm{KL}}(P\|Q) \neq D_{\mathrm{KL}}(Q\|P), \text{ if } P \neq Q. - KL ıraksaması negatif değildir, yani .. math:: D_{\mathrm{KL}}(P\|Q) \geq 0 Eşitliğin yalnızca :math:`P = Q` olduğunda geçerli olduğuna dikkat edin. - :math:`p(x)> 0` ve :math:`q(x) = 0` şeklinde bir :math:`x` varsa, :math:`D_{\mathrm{KL}}(P\|Q) = \infty`. - KL ıraksaması ile karşılıklı bilgi arasında yakın bir ilişki vardır. :numref:`fig_mutual_information` içinde gösterilen ilişkinin yanı sıra, :math:`I(X, Y)`'da aşağıdaki terimlerle sayısal olarak eşdeğerdir: 1. :math:`D_{\mathrm{KL}}(P(X, Y) \ \| \ P(X)P(Y))`; 2. :math:`E_Y \{ D_{\mathrm{KL}}(P(X \mid Y) \ \| \ P(X)) \}`; 3. :math:`E_X \{ D_{\mathrm{KL}}(P(Y \mid X) \ \| \ P(Y)) \}`. İlk terim için, karşılıklı bilgiyi :math:`P(X, Y)` ile :math:`P(X)` ve :math:`P(Y)` arasındaki KL ıraksaması olarak yorumluyoruz ve bu bileşik dağılımın bağımsız oldukları haldeki dağılımdan ne kadar farklı olduğunun bir ölçüsüdür. İkinci terimde, karşılıklı bilgi bize :math:`X` değerinin dağılımını öğrenmekten kaynaklanan :math:`Y` hakkındaki belirsizlikteki ortalama azalmayı anlatır. Üçüncü terimde benzer şekildedir. Örnek ~~~~~ Simetrisizliği açıkça görmek için bir yapay örneğin üzerinden geçelim. İlk olarak, :math:`10000` uzunluğunda üç tensör oluşturup sıralayalım: :math:`N(0, 1)` normal dağılımını izleyen bir hedef tensör :math:`p`, sırasıyla :math:`N(-1, 1)` ve :math:`N(1, 1)` normal dağılımları izleyen iki aday tensörümüz :math:`q_1` ve :math:`q_2` var. .. raw:: html
mxnetpytorchtensorflow
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python random.seed(1) nd_len = 10000 p = np.random.normal(loc=0, scale=1, size=(nd_len, )) q1 = np.random.normal(loc=-1, scale=1, size=(nd_len, )) q2 = np.random.normal(loc=1, scale=1, size=(nd_len, )) p = np.array(sorted(p.asnumpy())) q1 = np.array(sorted(q1.asnumpy())) q2 = np.array(sorted(q2.asnumpy())) .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python torch.manual_seed(1) tensor_len = 10000 p = torch.normal(0, 1, (tensor_len, )) q1 = torch.normal(-1, 1, (tensor_len, )) q2 = torch.normal(1, 1, (tensor_len, )) p = torch.sort(p)[0] q1 = torch.sort(q1)[0] q2 = torch.sort(q2)[0] .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python tensor_len = 10000 p = tf.random.normal((tensor_len, ), 0, 1) q1 = tf.random.normal((tensor_len, ), -1, 1) q2 = tf.random.normal((tensor_len, ), 1, 1) p = tf.sort(p) q1 = tf.sort(q1) q2 = tf.sort(q2) .. raw:: html
.. raw:: html
:math:`q_1` ve :math:`q_2`, y eksenine göre simetrik olduğundan (yani, :math:`x = 0`), :math:`D_{\mathrm{KL}}(p\|q_1)` ve :math:`D_{\mathrm{KL}}(p\|q_2)` arasında benzer bir KL ıraksaması bekleriz. Aşağıda görebileceğiniz gibi, :math:`D_{\mathrm{KL}}(p\|q_1)` ve :math:`D_{\mathrm{KL}}(p\|q_2)` arasında yalnızca :math:`\% 3`'ten daha az fark var. .. raw:: html
mxnetpytorchtensorflow
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python kl_pq1 = kl_divergence(p, q1) kl_pq2 = kl_divergence(p, q2) similar_percentage = abs(kl_pq1 - kl_pq2) / ((kl_pq1 + kl_pq2) / 2) * 100 kl_pq1, kl_pq2, similar_percentage .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output (8470.638, 8664.998, 2.268492904612395) .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python kl_pq1 = kl_divergence(p, q1) kl_pq2 = kl_divergence(p, q2) similar_percentage = abs(kl_pq1 - kl_pq2) / ((kl_pq1 + kl_pq2) / 2) * 100 kl_pq1, kl_pq2, similar_percentage .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output (8582.0341796875, 8828.3095703125, 2.8290698237936858) .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python kl_pq1 = kl_divergence(p, q1) kl_pq2 = kl_divergence(p, q2) similar_percentage = abs(kl_pq1 - kl_pq2) / ((kl_pq1 + kl_pq2) / 2) * 100 kl_pq1, kl_pq2, similar_percentage .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output (8717.686, 8713.572, 0.047194313735069146) .. raw:: html
.. raw:: html
Bunun aksine, :math:`D_{\mathrm{KL}}(q_2 \|p)` ve :math:`D_{\mathrm{KL}}(p \| q_2)`'nın yaklaşık :math:`\% 40` farklı olduğunu görebilirsiniz. Aşağıda gösterildiği gibi. .. raw:: html
mxnetpytorchtensorflow
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python kl_q2p = kl_divergence(q2, p) differ_percentage = abs(kl_q2p - kl_pq2) / ((kl_q2p + kl_pq2) / 2) * 100 kl_q2p, differ_percentage .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output (13536.835, 43.88680093791528) .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python kl_q2p = kl_divergence(q2, p) differ_percentage = abs(kl_q2p - kl_pq2) / ((kl_q2p + kl_pq2) / 2) * 100 kl_q2p, differ_percentage .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output (14130.125, 46.18621024399691) .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python kl_q2p = kl_divergence(q2, p) differ_percentage = abs(kl_q2p - kl_pq2) / ((kl_q2p + kl_pq2) / 2) * 100 kl_q2p, differ_percentage .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output (13411.012, 42.463527960050804) .. raw:: html
.. raw:: html
Çapraz Entropi -------------- Bilgi teorisinin derin öğrenmedeki uygulamalarını merak ediyorsanız, işte size hızlı bir örnek. :math:`P` gerçek dağılımını :math:`p(x)` olasılık dağılımıyla ve tahmini :math:`Q` dağılımını :math:`q(x)` olasılık dağılımıyla tanımlıyoruz ve bunları bu bölümün geri kalanında kullanacağız. Verilen :math:`n` veri örneklerine, {:math:`x_1, \ldots, x_n`}, ait bir ikili sınıflandırma problemini çözmemiz gerektiğini varsayalım. Sırasıyla :math:`1` ve :math:`0`'ı pozitif ve negatif sınıf etiketi :math:`y_i` olarak kodladığımızı ve sinir ağımızın :math:`\theta` parametresi ile ifade edildiğini varsayalım. :math:`\hat{y}_i = p_{\theta}(y_i \mid x_i)` için en iyi :math:`\theta`'yı bulmayı hedeflersek, maksimum logaritmik-olabilirlik yaklaşımını şurada, :numref:`sec_maximum_likelihood`, görüldüğü gibi uygulamak doğaldır. Daha belirleyici olmak gerekirse, :math:`y_i` gerçek etiketleri ve :math:`\hat{y}_i= p_{\theta}(y_i \mid x_i)` tahminleri için pozitif olarak sınıflandırılma olasılığı :math:`\pi_i= p_{\theta}(y_i = 1 \mid x_i)`'dir. Bu nedenle, logaritmik-olabilirlik işlevi şöyle olacaktır: .. math:: \begin{aligned} l(\theta) &= \log L(\theta) \\ &= \log \prod_{i=1}^n \pi_i^{y_i} (1 - \pi_i)^{1 - y_i} \\ &= \sum_{i=1}^n y_i \log(\pi_i) + (1 - y_i) \log (1 - \pi_i). \\ \end{aligned} :math:`l(\theta)` logaritmik-olabilirlik fonksiyonunu maksimize etmek, :math:`- l(\theta)`'yı küçültmekle aynıdır ve bu nedenle en iyi :math:`\theta`'yı buradan bulabiliriz. Yukarıdaki kaybı herhangi bir dağılımda genelleştirmek için :math:`-l(\theta)`'yı *çapraz entropi kaybı*, :math:`\mathrm{CE}(y, \hat{y})` olarak adlandırdık, burada :math:`y` doğru dağılımı, :math:`P`'yi izler ve :math:`\hat{y}` tahmini dağılım :math:`Q`'yu izler. Tüm bunlar, maksimum olabilirlik üzerinde çalışılarak elde edildi. Bununla birlikte, yakından bakarsak, :math:`\log(\pi_i)` gibi terimlerin bizim hesaplamamıza girdiğini görebiliriz ki bu, ifadeyi bilgi teorik bakış açısıyla anlayabileceğimizin sağlam bir göstergesidir. Resmi (Formal) Tanım ~~~~~~~~~~~~~~~~~~~~ KL ıraksaması gibi, rastgele bir değişken :math:`X` için, tahmini dağılım :math:`Q` ile gerçek dağılım :math:`P` arasındaki ıraksamayı (sapmayı) *çapraz entropi (ÇE)* aracılığıyla ölçebiliriz, .. math:: \mathrm{ÇE}(P, Q) = - E_{x \sim P} [\log(q(x))]. :label: eq_ce_def Yukarıda tartışılan entropinin özelliklerini kullanarak, bunu :math:`H(P)` entropisinin :math:`P` ve :math:`Q` arasındaki KL ıraksaması ile toplamı olarak da yorumlayabiliriz, yani, .. math:: \mathrm{ÇE} (P, Q) = H(P) + D_{\mathrm{KL}}(P\|Q). Çapraz entropi kaybını aşağıdaki gibi uygulayabiliriz. .. raw:: html
mxnetpytorchtensorflow
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def cross_entropy(y_hat, y): ce = -np.log(y_hat[range(len(y_hat)), y]) return ce.mean() .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def cross_entropy(y_hat, y): ce = -torch.log(y_hat[range(len(y_hat)), y]) return ce.mean() .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def cross_entropy(y_hat, y): # `tf.gather_nd`, bir tensörün belirli indekslerini seçmek için kullanılır. ce = -tf.math.log(tf.gather_nd(y_hat, indices = [[i, j] for i, j in zip( range(len(y_hat)), y)])) return tf.reduce_mean(ce).numpy() .. raw:: html
.. raw:: html
Şimdi etiketler ve tahminler için iki tensör tanımlayalım ve bunların çapraz entropi kaybını hesaplayalım. .. raw:: html
mxnetpytorchtensorflow
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python labels = np.array([0, 2]) preds = np.array([[0.3, 0.6, 0.1], [0.2, 0.3, 0.5]]) cross_entropy(preds, labels) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output array(0.94856) .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python labels = torch.tensor([0, 2]) preds = torch.tensor([[0.3, 0.6, 0.1], [0.2, 0.3, 0.5]]) cross_entropy(preds, labels) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output tensor(0.9486) .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python labels = tf.constant([0, 2]) preds = tf.constant([[0.3, 0.6, 0.1], [0.2, 0.3, 0.5]]) cross_entropy(preds, labels) .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output 0.94856 .. raw:: html
.. raw:: html
Özellikler ~~~~~~~~~~ Bu bölümün başında belirtildiği gibi, çapraz entropi :eq:`eq_ce_def` optimizasyon probleminde bir kayıp fonksiyonunu tanımlamak için kullanılabilir. Aşağıdakilerin eşdeğer olduğu ortaya çıkar: 1. :math:`P` dağılımı için :math:`Q` tahmini olasılığının en üst düzeye çıkarılması (yani, :math:`E_{x \sim P} [\log (q(x))]`); 2. Çapraz entropiyi en aza indirme :math:`\mathrm{E}(P, Q)`; 3. KL ıraksamasının en aza indirilmesi :math:`D_{\mathrm {KL}}(P\|Q)`. Çapraz entropinin tanımı, :math:`H(P)` gerçek verisinin entropisi sabit olduğu sürece, amaç fonksiyonu 2 ve amaç fonksiyonu 3 arasındaki eşdeğer ilişkiyi dolaylı olarak kanıtlar. Çok Sınıflı Sınıflandırmanın Amaç Fonksiyonu Olarak Çapraz Entropi ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Çapraz entropi kaybı :math:`\mathrm{ÇE}` ile sınıflandırma amaç fonksiyonunun derinliklerine inersek, :math:`\mathrm{ÇE}`'yi minimize etmenin :math:`L` logaritmik-olabilirlik fonksiyonunu maksimize etmeye eşdeğer olduğunu bulacağız. Başlangıç olarak, :math:`n` örnekli bir veri kümesi verildiğini ve bunun :math:`k` sınıfa sınıflandırılabileceğini varsayalım. Her :math:`i` veri örneği için, :math:`k`-sınıf etiketini :math:`\mathbf{y}_i = (y_{i1}, \ldots, y_{ik})` ile *birebir kodlama* ile temsil ederiz. Belirleyici olmak gerekirse, :math:`i` örneği :math:`j` sınıfına aitse, o zaman :math:`j.` girdisini :math:`1` olarak ve diğer tüm bileşenleri :math:`0` olarak kuruyoruz, yani, .. math:: y_{ij} = \begin{cases}1 & j \in J; \\ 0 &\text{aksi takdirde.}\end{cases} Örneğin, çok sınıflı bir sınıflandırma problemi :math:`A`, :math:`B` ve :math:`C` olmak üzere üç sınıf içeriyorsa, :math:`\mathbf{y}_i` etiketleri {:math:`A: (1, 0, 0); B: (0, 1, 0); C: (0, 0, 1)`}'dir. Sinir ağımızın :math:`\theta` parametresi ifade edildiğini varsayalım. Doğru etiket vektörleri :math:`\mathbf{y}_i` ve tahminleri için: .. math:: \hat{\mathbf{y}}_i= p_{\theta}(\mathbf{y}_i \mid \mathbf{x}_i) = \sum_{j=1}^k y_{ij} p_{\theta} (y_{ij} \mid \mathbf{x}_i). Dolayısıyla, *çapraz entropi kaybı*: .. math:: \mathrm{ÇE}(\mathbf{y}, \hat{\mathbf{y}}) = - \sum_{i=1}^n \mathbf{y}_i \log \hat{\mathbf{y}}_i = - \sum_{i=1}^n \sum_{j=1}^k y_{ij} \log{p_{\theta} (y_{ij} \mid \mathbf{x}_i)}.\\ Öte yandan, soruna maksimum olabilirlik tahminiyle de yaklaşabiliriz. Başlangıç ​​olarak, hızlı bir şekilde :math:`k`-sınıflı bir multinoulli dağılımını sunalım. Bu, Bernoulli dağılımının ikili sınıftan çoklu sınıfa doğru bir uzantısıdır. Rastgele bir değişken :math:`\mathbf{z} = (z_{1}, \ldots, z_{k})`, :math:`k`-sınıf *multinoulli dağılımını*, :math:`\mathbf{p} =` (:math:`p_{1}, \ldots, p_{k}`), izliyor, yani .. math:: p(\mathbf{z}) = p(z_1, \ldots, z_k) = \mathrm{Multi} (p_1, \ldots, p_k), \text{ öyle ki } \sum_{i=1}^k p_i = 1, o zaman :math:`\mathbf{z}` bileşik olasılık kütle fonksiyonu (o.k.f.): .. math:: \mathbf{p}^\mathbf{z} = \prod_{j=1}^k p_{j}^{z_{j}}. Görülebileceği gibi, her veri örneğinin etiketi, :math:`\mathbf{y}_i`, :math:`k`-sınıflı :math:`\boldsymbol{\pi} =` (:math:`\pi_{1}, \ldots, \pi_{k}`) olasılıklı bir multinoulli dağılımını takip ediyor. Bu nedenle, her veri örneği :math:`\mathbf{y}_i` için bileşik o.k.f :math:`\mathbf{\pi}^{\mathbf{y}_i} = \prod_{j=1}^k \pi_{j}^{y_{ij}}`'dir. Bu nedenle, logaritmik-olabilirlik işlevi şöyle olacaktır: .. math:: \begin{aligned} l(\theta) = \log L(\theta) = \log \prod_{i=1}^n \boldsymbol{\pi}^{\mathbf{y}_i} = \log \prod_{i=1}^n \prod_{j=1}^k \pi_{j}^{y_{ij}} = \sum_{i=1}^n \sum_{j=1}^k y_{ij} \log{\pi_{j}}.\\ \end{aligned} Maksimum olabilirlik tahmini olduğundan, :math:`\pi_{j} = p_{\theta} (y_{ij} \mid \mathbf{x}_i)` elimizdeyken :math:`l(\theta)` amaç fonksiyonunu maksimize ediyoruz. Bu nedenle, herhangi bir çok-sınıflı sınıflandırma için, yukarıdaki log-olabilirlik fonksiyonunu, :math:`l(\theta)`, maksimize etmek, ÇE kaybını :math:`\mathrm{ÇE}(y, \hat{y})` en aza indirmeye eşdeğerdir. Yukarıdaki kanıtı test etmek için, yerleşik ``NegativeLogLikelihood`` ölçütünü uygulayalım. Önceki örnekte olduğu gibi aynı ``labels`` (etiketler) ve ``preds`` (tahminler) değişkenlerini kullanarak, 5 ondalık basamağa kadar önceki örnekteki aynı sayısal kaybı elde edeceğiz. .. raw:: html
mxnetpytorchtensorflow
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python nll_loss = NegativeLogLikelihood() nll_loss.update(labels.as_nd_ndarray(), preds.as_nd_ndarray()) nll_loss.get() .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output ('nll-loss', 0.9485599994659424) .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python # PyTorch'ta çapraz entropi kaybının uygulanması `nn.LogSoftmax()` ve # `nn.NLLLoss()` öğelerini birleştirir nll_loss = NLLLoss() loss = nll_loss(torch.log(preds), labels) loss .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output tensor(0.9486) .. raw:: html
.. raw:: html
.. raw:: latex \diilbookstyleinputcell .. code:: python def nll_loss(y_hat, y): # Birebir vektörlere çevir y = tf.keras.utils.to_categorical(y, num_classes= y_hat.shape[1]) # Tanımdan negatif logaritmik-olabilirliği hesaplamayacağız. # Bunun yerine döngüsel bir argüman izleyeceğiz. Bize NLL verecek olan çapraz entropiyi # hesaplarsak, NLL, `cross_entropy` ile aynı olur. cross_entropy = tf.keras.losses.CategoricalCrossentropy( from_logits = True, reduction = tf.keras.losses.Reduction.NONE) return tf.reduce_mean(cross_entropy(y, y_hat)).numpy() loss = nll_loss(tf.math.log(preds), labels) loss .. raw:: latex \diilbookstyleoutputcell .. parsed-literal:: :class: output 0.94856 .. raw:: html
.. raw:: html
Özet ---- - Bilgi teorisi, bilgiyi kodlama, kod çözme, iletme ve üzerinde oynama ile ilgili bir çalışma alanıdır. - Entropi, farklı sinyallerde ne kadar bilginin sunulduğunu ölçen birimdir. - KL ıraksaması, iki dağılım arasındaki farklılığı da ölçebilir. - Çapraz Entropi, çok sınıflı sınıflandırmanın amaç işlevi olarak görülebilir. Çapraz entropi kaybını en aza indirmek, logaritmik-olabilirlik fonksiyonunu maksimize etmeye eşdeğerdir. Alıştırmalar ------------ 1. İlk bölümdeki kart örneklerinin gerçekten iddia edilen entropiye sahip olduğunu doğrulayınız. 2. :math:`D(p\|q)` KL ıraksamasının tüm :math:`p` ve :math:`q` dağılımları için negatif olmadığını gösteriniz. İpucu: Jensen'in eşitsizliğini kullanınız, yani :math:`-\log x`'in dışbükey (konveks) bir fonksiyon olduğu gerçeğini kullanınız. 3. Entropiyi birkaç veri kaynağından hesaplayalım: - Bir daktiloda bir maymun tarafından üretilen çıktıyı izlediğinizi varsayınız. Maymun, daktilonun :math:`44` tane tuşundan herhangi birine rasgele basar (henüz herhangi bir özel tuşun veya shift tuşunun bulunmadığını varsayabilirsiniz). Karakter başına kaç bit rastgelelik gözlemliyorsunuz? - Maymundan mutsuz olduğunuz için, onun yerine sarhoş bir dizici koydunuz. Tutarlı olmasa da kelimeler üretebiliyor. Bununla birlikte, :math:`2000` tanelik bir kelime dağarcığından rastgele bir kelime seçiyor. Bir kelimenin ortalama uzunluğunun İngilizce olarak :math:`4.5` harf olduğunu varsayalım. Şimdi karakter başına kaç bit rastgelelik gözlemliyorsunuz? - Sonuçtan hâlâ memnun olmadığınızdan dizgiciyi yüksek kaliteli bir dil modeliyle değiştiriyorsunuz. Dil modeli şu anda kelime başına :math:`15` noktaya kadar şaşkınlık (perplexity) sayıları elde edebiliyor. Bir dil modelinin *şaşkınlık* karakteri, bir dizi olasılığın geometrik ortalamasının tersi olarak tanımlanır, her olasılık sözcükteki bir karaktere karşılık gelir. Belirleyici olmak gerekirse, eğer verilne bir kelimenin uzunluğu :math:`l` ise, o zaman :math:`\mathrm{PPL}(\text{kelime}) = \left[\prod_i p(\text{karakter}_i)\right]^{ -\frac{1}{l}} = \exp \left[ - \frac{1}{l} \sum_i{\log p(\text{karakter}_i)} \right]`. Test kelimesinin 4.5 harfli olduğunu varsayalım, şimdi karakter başına kaç bit rastgelelik gözlemliyorsunuz? 4. Neden :math:`I(X, Y) = H(X) - H(X|Y)` olduğunu sezgisel olarak açıklayın. Ardından, her iki tarafı da bileşik dağılıma göre bir beklenti şeklinde ifade ederek bunun doğru olduğunu gösterin. 5. İki Gauss dağılımı, :math:`\mathcal{N} (\mu_1, \sigma_1^2)` ve :math:`\mathcal{N}(\mu_2, \sigma_2^2)`, arasındaki KL ıraksaması nedir? .. raw:: html
mxnetpytorchtensorflow
.. raw:: html
`Tartışmalar `__ .. raw:: html
.. raw:: html
`Tartışmalar `__ .. raw:: html
.. raw:: html
`Tartışmalar `__ .. raw:: html
.. raw:: html