Kısım III · Merak · Bölüm 49

micrograd 1: Hesap Grafiği

Değerler ve hesabın kaydını tutmak (Values and the computational graph)

1. Kat 10Yapay zekâ uygulamasının hesap motorumicrograd, bu katta çalışan programın içindeki küçük bir kütüphane; yeni bir fiziksel kat değil.
2. Kat 5Python: sınıflar ve nesnelerSayının yanına işlemi ve bağlantılarını koymamızı sağlayan dil araçları.
3. Kat 3İşlemci, bellek, GPUNesneler bellekte tutulur, işlemler işlemcide yapılır. Büyük ağlar GPU'dan güç alır; bu skaler Python motoru GPU gerektirmez.
4. Kat 0–2Bit, mantık ve hesap devreleriEn alttaki toplama değişmedi; ona ilişkin bir kayıt yapısı ekliyoruz.

Bu bölümün sonunda Value(2.0)'ın neden sıradan 2.0'dan daha çok bilgi taşıdığını, bir toplamanın nasıl hem sonuç hem bağlantı ürettiğini ve ileri geçişin ne olduğunu okuyabileceksin. Henüz gradyanları geriye taşımayacağız. Önce üzerinde yürüyeceğimiz merdiveni kurmak gerekiyor.

49.1 Value nesnesi: bir sayı ve onu üreten işlem

Bir hesap makinesinde 2 * (-3) + 10 yazınca 4 görürsün. “4'ün geldiği yol neydi?” dersen, yalnız 4 sayısı cevap vermez: 1+3 de 4, 8/2 de 4. Sonuç bir başına geçmişi saklamaz. micrograd bu bilgi kaybını önlemek için sayıyı bir Value nesnesi (Value object) içine koyar. Nesne hem sayıyı hem onu üreten hesap adımına ilişkin bağlantıları tutar. Depodaki engine.py dosyasının bütün merkezî fikri budur.¹

Önce kapsamı küçültelim: buradaki her nesne tek bir skaler (scalar), yani tek sayı taşır. Bir resmin tamamını veya büyük bir sayı tablosunu tek Value'ya koymuyoruz. README'nin söylediği gibi nöronun hesabı tek tek toplama ve çarpmalarına ayrılır. Bu, düşünceyi görünür kılan bir öğretim tercihidir; “her gerçek model bu nesnelerle çalışır” anlamına gelmez.²

Depodaki gerçek nesnenin başlangıcı

Aşağıdaki parça Karpathy'nin micrograd/engine.py dosyasındaki Value sınıfının kurucusudur. Tam motorun içinden bir kesit okuyoruz; bunu tek başına yeni bir motor sanma.¹

class Value:
    def __init__(self, data, _children=(), _op=''):
        self.data = data
        self.grad = 0
        self._backward = lambda: None
        self._prev = set(_children)
        self._op = _op

• class Value: bir nesne kalıbına ad verir. Bölüm 21'deki sınıf fikri; JavaScript'teki nesne alanlarının Python karşılığıyla karşılaşıyoruz.
• __init__ yeni nesne oluşturulurken çalışır. self oluşturulan nesnenin kendisidir. data içine konacak sayıdır; diğer iki girdinin varsayılanı boş bağlantılar ve boş işlem adıdır.
• self.data = data sayıyı saklar. self.grad = 0 daha sonra sonucun bu sayıya hassasiyetini yazacağımız alanı başlangıçta sıfırlar. Bu sıfır, türevin hesaplanıp sıfır bulunduğu anlamına gelmez.
• self._backward = lambda: None şimdilik hiçbir iş yapmayan küçük bir fonksiyon saklar. İşlemle üretilmiş düğümler bu alanı kendi geri taşıma tarifiyle doldurur; onu Bölüm 50'ye bırakıyoruz.
• self._prev = set(_children) sayıyı üretirken kullanılan önceki nesneleri bir kümede tutar. _children dosyadaki girdi adıdır; bağlantının anlamı “bunu üretmek için hangi önceki değerlere ihtiyaç vardı?”dır. Küme, aynı nesnenin tekrarını tek kayıt yapar.
• self._op = _op düğümün +, * gibi işlem etiketini saklar; dışarıdan verilen başlangıç sayısında bu etiket boştur.

Alt çizgiyle başlayan alanlar burada motorun iç işleyişine ait isimlerdir. İnceleyebiliriz, ama gündelik kullanıcının bunları elle doldurması gerekmez. data ile grad'ı aynı kutuda tutmak da onları aynı şey yapmaz: birincisi değeri, ikincisi seçilmiş son çıktının bu değere göre türevini taşıyacaktır. Python'un nesne ve özel metot mekanizmasının resmî karşılığı Data model belgesindedir.³

Gerçek micrograd ile ilk çalıştırma

Aşağıdaki örnekler, depodaki engine.py indirilerek gerçek Value sınıfıyla çalıştırıldı. Kitabı okurken kendi Python ortamında kütüphaneyi kullanmak istersen README'deki paket adı micrograd; bir terminalde python3 -m pip install micrograd ile kurabilirsin. Kitabın metnini anlamak için kurulum şart değil; aşağıdaki çıktılar gerçek çalıştırmanın kaydıdır.²

from micrograd.engine import Value

a = Value(2.0)
b = Value(-3.0)
e = a * b

print(a)
print(e)
print(e._op)
print(sorted(v.data for v in e._prev))

Value(data=2.0, grad=0)
Value(data=-6.0, grad=0)
*
[-3.0, 2.0]

from ... import Value, sınıfı modülünden alır; bu, Bölüm 27'deki içe aktarma fikridir. İki sonraki satır ayrı başlangıç nesneleri kurar. e = a * b çarpımı yaparken sonuç nesnesini de kurar. İlk iki print nesnelerin okunabilir gösterimini, üçüncüsü işlemin etiketini gösterir. Son satır, e._prev içindeki her nesnenin data alanını alıp sıralar ve yazdırır. sorted yalnız ekrandaki sırayı sabitlemek içindir; motorun matematiği için −3'ün önce yazılmasının önemi yoktur.

Çıktıda grad=0 görüyoruz, ama çarpımın a'ya göre türevi −3 değil miydi? Evet, Bölüm 48.3'te öyle bulduk. Burada henüz o türevi hesaplatmadık. Bellekteki başlangıç sıfırını matematiksel bir hüküm sanmamak, motoru doğru okumanın ilk şartı.

“Yıldız” nasıl yeni bir nesne üretiyor?

Python bir sınıfa, * ve + gibi işlemlerin kendi nesneleri için ne yapacağını söyleme imkânı verir. Bu mekanizmanın adı işleç yükleme (operator overloading). a * b, bu sınıfta __mul__ metoduna; a + b ise __add__ metoduna karşılık gelir. Matematik işaretini değiştirmiyoruz: onun yanına kayıt tutma davranışı ekliyoruz.³

Depoda çarpmanın ileri hesabını yapan merkezî satır şudur:

out = Value(self.data * other.data, (self, other), '*')

İlk parça gerçek sayıları çarpar. İkinci parça, kullanılan aynı iki nesneyi sonucun bağlantıları olarak verir; sayıların yalnız kopyasını vermiyor. Son parça etiket. Motor buna ek olarak geri taşıma tarifini out._backward'a koyar ve out'u döndürür. Toplamanın karşılığı Value(self.data + other.data, (self, other), '+'). Bu iki satırı okuyabilmek, grafiğin nasıl kendiliğinden oluştuğunu anlamaya yeter.¹

Bir işlemdeki diğer taraf sıradan Python sayısıysa motor önce onu da Value'ya sarar: örneğin a + 1 yalnız “a ile bir arasında düşünsel bir bağ” değildir; 1 için de bir nesne kurulur. Depodaki __radd__ ve __rmul__ metotları da sayının solda olduğu 1 + a ve 2 * a durumlarını karşılar. Tam dosyada bu küçük kolaylıklar var; onları sinir ağının yeni bir matematik kuralı sanma.¹

49.2 Hesap grafiği: işlemlerin ağacı ve paylaşılan yollar

Şimdi aynı kaydı birkaç adım boyunca tutalım. Hesap grafiği (computational graph), hangi sayının hangi önceki sayılardan hangi işlemle üretildiğinin bağlı gösterimidir. Buradaki “grafik”, önceki bölümdeki yatay x–dikey y eğrisi değildir: sayıların bağımlılık haritasıdır. “Çizge” sözcüğünü de aynı bağlı yapı için görebilirsin; bu konuda kitabın başlığındaki “hesap grafiği” adını kullanacağız.²⁴

a =  2 ─┐
        ├─ çarp ─► e = -6 ─┐
b = -3 ─┘                 ├─ topla ─► d = 4 ─┐
c = 10 ───────────────────┘                 ├─ çarp ─► L = -8
f = -2 ─────────────────────────────────────┘

Bu, Karpathy'nin ilk micrograd ders defterindeki aritmetik örnektir: e = a*b, d = e+c, L = d*f.⁴ L burada yalnız sonucun adıdır. Değeri −8 olduğuna göre ona şimdiden “kayıp mutlaka negatif olur” gibi bir anlam yükleme; bu bir aritmetik alıştırması. Eğitimde hangi sayıya kayıp diyeceğimizi Bölüm 52'de kuracağız.

Düğüm, kenar ve yön

Bir düğüm (node) bu hesapta saklanan bir değerdir; kenar (edge) ise bir değerin bir sonraki hesapta kullanıldığını gösteren bağlantıdır. Çizimde okları girdiden sonuca doğru çizdik. Kodun _prev alanı, bu bağlantıları sonuçtan bakıp önceki değerlere erişebileceğimiz biçimde saklar. Okları hangi yönden okuduğunu söylemezsen “çocuk”, “ebeveyn”, “önceki” gibi kelimeler kolayca karışır. Bu kitapta önceki değer, o işlemin girdisi demektir.¹⁴

Bu aritmetik örnekte yedi Value var: dört başlangıç sayısı a,b,c,f ve işlemle üretilen üç ara/son değer e,d,L. Karpathy'nin çizim fonksiyonu ayrıca işlemleri küçük yuvarlak düğümlerle çizer. Bu yalnız bir görselleştirme tercihi: * için ayrı daire çizilmesi, motorun içinde ayrıca yeni bir Value saklandığı anlamına gelmez. İşlem etiketi sonuç nesnesinin alanındadır.⁴

Neden her zaman ağaç değil?

Bölüm 11'in ağacını hatırla: dallanarak aşağı inmek kolaydır. Yukarıdaki çizim ağaç gibi okunabilir. Fakat aynı ara değer iki farklı yerde kullanılabilir; o zaman iki yol tek nesneyi paylaşır. micrograd README'si bu yüzden daha genel adı kullanır: yönlü çevrimsiz grafik (directed acyclic graph, DAG). Yönlüdür, çünkü bağımlılığın bir yönü var; çevrimsizdir, çünkü yeni hesaplanan sonuçtan eski girdilere dönerek aynı hesap bağımlılığında kendisine ulaşan bir döngü oluşmaz. Burada varsayım, motorun işlemleriyle kurulan bağlantıları sonradan elle bozmamamızdır.¹²

x ──► [x * x] ──► u ──┐
└─────────────────────┼─► [u + x] ──► y

u = x*x, y = u+x diyelim. x hem karesine giden yolda hem doğrudan toplamada kullanıldı. Kâğıtta x'i üç kez yazabilirsin; bilgisayarda üç ayrı x nesnesi olmak zorunda değil. Bölüm 10.6'daki değer–referans ayrımını kullanıyoruz: aynı nesneye birden çok yerden başvurabiliyoruz. İşlemler grafiğinde bu paylaşımı doğru kaydetmek, sonraki bölümde etkileri doğru toplamak için gerekli.¹⁵

from micrograd.engine import Value

x = Value(3.0)
u = x * x
y = u + x

print(u.data, y.data)
print(len(u._prev), len(y._prev))
print(x in u._prev, x in y._prev)
print(x.grad)

9.0 12.0
1 2
True True
0

İlk dört satır x'i ve ondan gelen iki sonucu kurar. len kümedeki farklı nesneleri sayar: çarpımın iki girdisi de aynı x olduğu için u._prev bir nesne taşır; toplamanın girdileri farklı u ve x olduğu için y._prev iki nesne taşır. in iki kümede de x'e bir bağlantı bulunduğunu doğrular. Son satır, ileri hesap yapılmış olsa da gradyanın henüz hesaplanmadığını gösterir.

Aynı sayı olmak, aynı nesne olmak değildir

from micrograd.engine import Value

x = Value(3.0)
ayni = x
baska = Value(3.0)
print(x is ayni)
print(x is baska)
print(x.data == baska.data)

True
False
True

ayni = x yeni bir Value üretmez; aynı nesneye ikinci bir ad verir. baska = Value(3.0) yeni nesne üretir, sayı eşit olsa bile kimlik farklıdır. Python'daki is nesnenin aynı olup olmadığını, son satırdaki == ise iki data sayısının eşitliğini sorar. Bu ayrım resmî nesne modelinin temelidir.³ Bir modelde aynı parametrenin yeniden kullanılması ile tesadüfen eşit değerde iki bağımsız parametrenin bulunması da aynı durum değildir.

49.3 İleri geçiş

Bağımlılıkları izleyerek girişlerden sonuca doğru değerleri hesaplamaya ileri geçiş (forward pass) denir. Yeni bir gizemli hesap yöntemi değil: şu ana kadar yaptığımız aritmetiğin adı. e için önce a ile b, d için önce e ile c, L için önce d ile f hazır olmalı. micrograd'da bu işlemleri yazarken sayılar hesaplanır ve grafik aynı anda kurulur.¹⁴

from micrograd.engine import Value

a = Value(2.0)
b = Value(-3.0)
c = Value(10.0)
f = Value(-2.0)
e = a * b
d = e + c
L = d * f

for ad, deger in (("a", a), ("b", b), ("c", c),
                  ("f", f), ("e", e), ("d", d), ("L", L)):
    print(f"{ad}: data={deger.data:.1f}, grad={deger.grad:.1f}")

a: data=2.0, grad=0.0
b: data=-3.0, grad=0.0
c: data=10.0, grad=0.0
f: data=-2.0, grad=0.0
e: data=-6.0, grad=0.0
d: data=4.0, grad=0.0
L: data=-8.0, grad=0.0

Dört başlangıç nesnesi ilk sayıları saklar. Üç sonraki satır, sırayla bir çarpma, bir toplama, bir çarpma yapar. Son döngünün her turunda ad okunabilir etiketi, deger ilgili nesneyi alır; print onun iki alanını birer ondalık basamakla gösterir. Bu etiketler motorun zorunlu alanları değildir; ekranda hangi satırın hangi değere ait olduğunu ayırmak için bizim listemizdedir.

İleri geçişin iki ürünü

İkinci ürünün varlığı birincisini değiştirmez: sıradan Python aritmetiği de −8 verir. Eklediğimiz şey daha doğru çarpma değil, çarpmanın bağlamını saklamaktır. Bunun bir bellek bedeli vardır; ara nesneler ve bağlantılar tutulur. Aynı kayıt daha sonra türev hesabını mümkün kılar. README'nin “dinamik olarak kurulan DAG” ifadesi, grafiği önceden ayrı bir şema olarak çizmemiz gerekmediğini anlatır: çalıştırılan bu işlemler kendi kayıtlarını üretir.¹²

İleri geçiş bir canlı elektronik tablo değildir

Burada önemli bir sınır var. a.data'yı daha sonra değiştirmek, daha önce hesaplanmış e.data, d.data ve L.data'yı kendiliğinden yeniden hesaplatmaz. Kaynak kodda her işlem sonuç nesnesine sayıyı bir kez yazar. Bağlantılar bir “sürekli güncel tut” sistemi değil, gerçekleşmiş hesabın kaydıdır. Farklı başlangıçlarla yeni sonucu istiyorsan işlemleri yeniden yürütmelisin.¹

Örneğin eski kayıt a = 2 için −8'i tutar. Yeni a = 2,01 ile hesabı baştan yürütürsen sonuç −7,94 olur. Bu iki farklı ileri geçiştir. Daha önemlisi, ileri geçiş ile geri hesap arasına eski girdileri değiştiren bir işlem sıkıştırmamalıyız: bu motorun geri taşıma kuralları bazı eski düğümlerin data alanlarını okur. Kaydettiğin hesap ile okuduğun sayılar artık aynı noktaya ait değilse türev güvenilir olmaz. Eğitimde doğru sıra ve yeni geçişler Bölüm 52'de kurulacak.¹

Küçük bir kayıt okuma alıştırması

Terminalde d._op yazdırıldığında + görmen gerekir; d._prev içinde e ile c bulunur. L._prev ise d ile f'yi gösterir, doğrudan bütün ilk girdileri değil. “L a'dan etkileniyor mu?” diye sormak için bu bağlantılarda birkaç adım geriye yürürsün. Bölüm 11'deki bağlı yapıyı okuma fikri işte burada somut bir iş görüyor.

Ders defterindeki trace fonksiyonu da sonuçtan başlayıp önceki düğümlere yürür; daha önce görülen nesneleri bir kümede tutar, böylece ortak bir düğümü tekrar tekrar toplamaz.⁴ Bu bölümde çizim kütüphanesi kurmak gerekmiyor: yukarıdaki metin şeması ve alanları yazdırmak kaydı okumaya yeter. Geri yayılım için gereken doğru yürüyüş sırası bir sonraki bölümün konusu.

49.4 Otomatik türev nedir?

Artık türevi otomatik hesaplamak için gereken malzeme görünür. Otomatik türev (automatic differentiation, autograd), hesabı bilinen küçük işlemlere ayırıp bu işlemlerin türev kurallarını hesap kaydına göre birleştirmektir. “Autograd” otomatik gradyan hesabı için karşılaşacağın addır; micrograd README'si kendisini küçük bir autograd motoru diye tanımlar. Burada türevini aldığımız şey, seçilmiş son skaler çıktının önceki sayılara hassasiyetidir.²⁵

Üç yolu birbirinden ayır

Otomatik türev motoru “bin farklı a deneyeyim” diye arama yapmaz. Dev bir cebirsel formülü önce yazıp sadeleştirmek zorunda da değildir. L = (a*b+c)*f hesabında her çarpmanın ve toplamanın kuralını, o geçişteki sayılarla kullanır. Yerel kurallar doğruysa ve işlem türevlenebilirse zincir kuralı o noktadaki türevi verir; kayan nokta ile hesaplamanın sayısal sınırları yine geçerlidir. “Otomatik” sözcüğü matematik kurallarının ortadan kalktığını değil, doğru sırada program tarafından yürütüldüğünü anlatır.¹⁵

Bu motorun seçtiği yön

Otomatik türev için farklı yürüyüş düzenleri olabilir; micrograd'ın seçtiği ters kip (reverse mode) hesabıdır. Son çıktıdan başlanır, önceki değerlere doğru hassasiyetler taşınır. Bu yürüyüşe geri yayılım (backpropagation) denir. Burada yalnız adını ve amacını yerleştiriyoruz: ileri geçiş değerleri, geri yayılım o değerlere ilişkin türevleri hesaplar. Nasıl çarptığını, paylaşılan yerde neden topladığını ve neden sıraya ihtiyaç duyduğunu Bölüm 50'de tek bir örnekte göreceğiz.²

Otomatik türev, otomatik öğrenme değildir

Bir çıktı için hassasiyetleri hesaplamış olmak, modelin eğitildiği anlamına gelmez. Henüz doğru cevapları seçmedik, bir hata ölçüsü tanımlamadık, parametreleri değiştirmedik. Bölüm 47'nin eğitim–çıkarım ayrımı burada da duruyor. Bir modelin sonucunu hesaplamak, sonucun türevini hesaplamak ve parametreleri yeni konuma taşımak üç ayrı iştir. İleri geçiş ilkini yapıyor; motorun geri tarafı ikincisini yapacak; eğitim döngüsü üçüncüsünü de bir araya getirecek.⁵

Bu yüzden motora “hukuk sorusunun anlamını kavradı” gibi bir yetenek yükleme. micrograd'ın Value nesnesi bir sayının anlamını bilmez; aynı aritmetik kurallarını kullanır. “Parametre” diye sakladığımız başlangıç değeriyle “girdi” diye sakladığımız başlangıç değerinin türevini motor aynı şekilde taşıyabilir. Hangilerinin eğitimde değiştirileceği motorun dışındaki model ve eğitim düzeninin kararıdır.¹⁵

Bu bölümde neler kuruldu

Value, tek bir sayıdan fazlasını taşıyan nesneydi: data, başlangıçta sıfır grad, önceki değerlere bağlantılar, işlem etiketi ve geri taşıma tarifi. Aritmetik işlemler yeni sonuç nesneleri üretirken hesap grafiğini kurdu. Grafiğin oklarını girdiden sonuca okuduk; nesnelerin _prev alanıyla ters yönde önceki değerlere eriştik. Ortak değerler kullanıldığında yapının yalnız bir ağaç değil DAG olduğunu gördük. İleri geçişte sonuç −8 bulundu; gradyanlar henüz hesaplanmadı. Otomatik türevin küçük türev kurallarını birleştirdiğini, kendiliğinden eğitim yapmadığını ayırdık.

Terimler sözlükte, Bölüm 49 başlığı altında. Şimdi eldeki kayıt üzerinde geriye yürüme zamanı.

Kaynaklar

1. Andrej Karpathy, micrograd/engine.py: Value alanları, işlem metotları, sayıyı Value'ya sarma, _prev kümesi, _backward fonksiyonları. Bu bölümdeki motor örnekleri bu gerçek dosyayla çalıştırıldı; alanlardan çıkarılan sınırlar, özellikle data değişikliğinin eski sonuçları yenilememesi, kaynak koddan okunmuştur.
2. Andrej Karpathy, micrograd README, giriş, Installation, Example usage, Tracing / visualization: skaler değerler, dinamik DAG, ters kip otomatik türev, paket adı ve öğretim amacı.
3. Python belgeleri, Data model, Objects, values and types, Basic customization, Emulating numeric types: nesne kimliği, __init__, __repr__, __add__, __mul__ ve ters işleç metotları.
4. Andrej Karpathy, micrograd_lecture_first_half_roughly.ipynb: a=2, b=−3, c=10, f=−2 örneği; Value, trace ve draw_dot. Depodaki motorun aksine bu defterin Value sınıfında ayrıca label alanı vardır; kitap örnekleri o alanı varsaymaz.
5. Stanford CS231n, Backpropagation, Intuitions, Compound expressions with chain rule, Backprop in practice: Staged computation, Summary: yerel türevleri birleştirme, ara değerleri saklama ve sembolik olarak dev formül açmadan gradyan hesaplama.