13 Nesne Yönelimli Programlama (OOP)

class MyModel(nn.Module): — modern AI’nın DNA’sı

Bölüm bilgisi

Mosh’un videosu: Chapters 31-34 (Classes → Quiz → Methods → Inheritance) (≈37 dk)
Bölüm aralığı: 3:43:58 — 4:20:46
Kaynaklar: Python docs — classes · PyTorch nn.Module · PEP 8 — class names
Okuma süresi: ≈60 dk

13.1 Bu Derste Ne Var? — KURSUN FİNALİ

Bu kursun son dersi. Mosh’un başlangıçtan beri öğrettiklerini bir araya toplayıp modern Python’un en güçlü kavramına ulaşıyoruz: nesne yönelimli programlama (OOP) ve class’lar.

Bu, aynı zamanda modern AI’nın yapı taşlarının oturduğu yerdir. PyTorch’taki class MyModel(nn.Module): deyimi — GPT-4’ün, Stable Diffusion’ın, Claude’un, BERT’in tümünün çekirdeği — tam bu derste öğreneceğimiz kavramın uygulamasıdır.

flowchart LR
    A["class Student:"] --> B["__init__ + self"]
    B --> C["Object yaratma"]
    C --> D["Methods"]
    D --> E["Inheritance"]
    E --> F["Dunders<br/>__call__, __getitem__"]
    F --> G["💎 class MyModel(nn.Module):"]
    G --> H["⚡ MODERN AI'NIN DNA'sı"]

    style G fill:#fff3e0,stroke:#f57c00,stroke-width:2px
    style H fill:#ffcdd2,stroke:#b71c1c,stroke-width:3px

Şekil 13.1: Ders 12’nin akış haritası — class’tan nn.Module’e ve kurs sonuna

Dersin yedi parçası:

Class motivasyonu. — Gerçek dünyayı modellemek.
class + __init__ + self.
Object yaratma + attribute erişim.
Methods.
Inheritance.
Special methods (dunders).
nn.Module — TAM ML sınıfı.

Builder Notu — KURSUN FİNALİ (en derin köprüler)

class MyModel(nn.Module): = modern AI’nın DNA’sı. Her sinir ağı, her LLM, her görüntü sınıflandırma bu pattern üzerine kurulu.
def __init__(self, ...): = layer setup. PyTorch’ta self.layer1 = nn.Linear(...).
def forward(self, x): = computation graph. Modelin verisini girdi-çıktı zincirine dönüştürür.
Inheritance: class MyModel(nn.Module): = AI mimari mirası. nn.Module’ün tüm özelliklerini al.
self = state encapsulation. Mosh’un “object’in kendi referansı” PyTorch’ta self.layers ile model içi state.
super().__init__() = parent constructor. PyTorch’ta zorunlu.
Special methods (dunders) = Python’un gücü. __call__ → model(x). __len__ → len(dataset). __getitem__ → dataset[i]. PyTorch DataLoader API’si bu dunders üzerine.

13.2 Class Motivasyonu

Mosh:

“çok var Bir dize ya da diziyi otomatikleştirmede gerçek dünyada temsil edemediğimiz şeyleri” — Mosh (Türkçe dublaj), 3:44:53

13.2.1 Python’un Sınırlı Tipleri

Şimdiye kadar:

int, float, str, bool, list, tuple, dict, set.

Bunlar soyut. Gerçek dünyada:

Öğrenci — ad, yaş, GPA, bölüm, davranışlar (kayıt ol, mezun ol).
Ürün — ad, fiyat, stok.
Sinir ağı — katmanlar, parametreler, forward davranışı, training/eval modu.

Tek bir int veya string ile temsil edemeyiz.

13.2.2 Çözüm — Kendi Veri Tipi

“sınıflarla ve nesnelerle neler yapabileceğimizi temelde kendimizinkini yaratabiliriz veri tipleri.” — Mosh (Türkçe dublaj), 3:45:15

Class ile kendi veri tipini tanımlarsın:

class Student:
    pass    # geçici - boş class

Şimdi Student Python’un yeni bir tipi.

13.2.3 Class vs Object

“a class is just like an overview of what the student data type is bir obje is an actual student” — Mosh (Türkçe dublaj), 3:51:05

Class = blueprint, kalıp.
Object (instance) = somut bir örnek.

Analoji:

Class Student = “öğrencinin ne olduğunu tanımlayan teorik kalıp”.
Object student1 = Student("Jim", ...) = gerçek bir öğrenci.

13.2.4 Class ML’de

Builder Notu — Blueprint → Object

import torch.nn as nn

# Class - blueprint:
class MyMLP(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.layer1 = nn.Linear(input_dim, hidden_dim)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        return x

# Object - actual model:
model_a = MyMLP(input_dim=784, hidden_dim=128, output_dim=10)
model_b = MyMLP(input_dim=512, hidden_dim=256, output_dim=10)
# 3 farkli model, ayni class blueprint'inden

Mosh’un “farklı öğrenciler yarat” mantığı = ML’de farklı model konfigürasyonları.

13.3 `class`, `init`, `self`

13.3.1 Class Tanımı

“way that I can do that is just by typing sınıf.” — Mosh (Türkçe dublaj), 3:46:43

class Student:
    pass

İsimlendirme: Class adları PascalCase. Student, NeuralNetwork, BertTokenizer.

13.3.2 `init` Constructor

“I want to create something called an initialize işlevi.” — Mosh (Türkçe dublaj), 3:47:40

class Student:
    def __init__(self, name, major, gpa, is_on_probation):
        self.name = name
        self.major = major
        self.gpa = gpa
        self.is_on_probation = is_on_probation

__init__ (init — initialize) = Python’un constructor’ı. Otomatik çağrılır.

İki alt çizgi (__) — “dunder” (double underscore) — Python’a özel anlam.

13.3.3 `self` — Instance Referansı

self her method’un ilk parametresidir. Object’in kendi kendine referansı.

def __init__(self, name, major, gpa, is_on_probation):
    self.name = name          # bu instance'in adi
    ...

C++/Java’da this; Python’da self.

13.3.4 Object Yaratma

# student.py
class Student:
    def __init__(self, name, major, gpa, is_on_probation):
        self.name = name
        self.major = major
        self.gpa = gpa
        self.is_on_probation = is_on_probation

# app.py
from student import Student

student1 = Student("Jim", "Business", 3.1, False)

Akış:

Student("Jim", "Business", 3.1, False) çağrısı.
Python yeni Student instance yaratır.
__init__(self, "Jim", "Business", 3.1, False) çağrılır.
__init__ içinde self.name = "Jim" …
Tamamlanan instance student1’e atanır.

self parametresi çağrıda yazılmaz — Python otomatik geçirir.

13.3.5 Attribute Erişim

student1 = Student("Jim", "Business", 3.1, False)

print(student1.name)              # Jim
print(student1.major)             # Business
print(student1.gpa)               # 3.1
print(student1.is_on_probation)   # False

13.3.6 PyTorch’ta `init`

Builder Notu — Modelin İskeleti

import torch.nn as nn

class SimpleClassifier(nn.Module):
    def __init__(self, input_dim, num_classes):
        super().__init__()             # nn.Module __init__'ini cagir
        self.feature_extractor = nn.Sequential(
            nn.Linear(input_dim, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
        )
        self.classifier = nn.Linear(128, num_classes)

    def forward(self, x):
        features = self.feature_extractor(x)
        return self.classifier(features)

model = SimpleClassifier(input_dim=784, num_classes=10)
print(model.classifier)     # Linear layer

Mosh’un self.name = name öğretişi, PyTorch’ta self.layer = nn.Linear(...) ile birebir aynı yapı. Sadece name yerine katman, katmanlar autograd ile gradient hesabına dahil.

super().__init__() modern Python OOP’sinin standart deyimi. PyTorch’ta zorunlu.

13.4 Methods — Class İçinde Fonksiyonlar

Object veri taşımakla kalmaz, iş de yapar.

13.4.1 Method Tanımı

class Student:
    def __init__(self, name, major, gpa, is_on_probation):
        self.name = name
        self.major = major
        self.gpa = gpa
        self.is_on_probation = is_on_probation

    def on_honor_roll(self):
        """GPA 3.5+ ise honor roll'da."""
        return self.gpa >= 3.5

    def graduate(self):
        """Mezuniyet acıklaması."""
        if self.gpa < 2.0:
            return f"{self.name} mezun olamaz - GPA dusuk"
        elif self.is_on_probation:
            return f"{self.name} probation'da"
        else:
            return f"Tebrikler {self.name}!"

Method = class içinde tanımlı fonksiyon. İlk parametre self.

13.4.2 Method Çağrısı

student1 = Student("Jim", "Business", 3.6, False)

print(student1.on_honor_roll())   # True
print(student1.graduate())        # Tebrikler Jim!

student1.on_honor_roll() aslında Student.on_honor_roll(student1) — Python student1’i self olarak geçirir.

13.4.3 Method’lar Argüman Alabilir

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Amount must be positive")
        self.balance += amount
        return self.balance

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount
        return self.balance

    def transfer(self, other, amount):
        self.withdraw(amount)
        other.deposit(amount)

deniz = BankAccount("Deniz", 1000)
aylin = BankAccount("Aylin", 500)
deniz.transfer(aylin, 300)
print(deniz.balance)      # 700
print(aylin.balance)      # 800

13.4.4 PyTorch’ta `forward()`

Builder Notu — Transformer Forward

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.d_model = d_model
        self.n_heads = n_heads
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)

    def forward(self, x, mask=None):
        """Tek bir attention block forward."""
        Q = self.W_q(x)
        K = self.W_k(x)
        V = self.W_v(x)

        scores = (Q @ K.transpose(-2, -1)) / (self.d_model ** 0.5)
        if mask is not None:
            scores = scores.masked_fill(mask == 0, float('-inf'))
        attn = scores.softmax(dim=-1)
        return self.W_o(attn @ V)

forward PyTorch’un en önemli method’u. Mosh’un student.on_honor_roll() mantığı, transformer’ın model.forward(x) mantığıyla birebir aynı yapıda: instance state’i kullanarak (self.W_q, self.gpa) bir hesaplama yap.

13.5 Inheritance — Class’tan Class Türetmek

13.5.1 Motivasyon

class Chef:
    def make_chicken(self):
        return "Tavuk pisir"

    def make_salad(self):
        return "Salata yap"

    def make_special_dish(self):
        return "Bbq tavuk"


class ChineseChef:
    def make_chicken(self):
        return "Tavuk pisir"      # AYNI Chef'le!

    def make_salad(self):
        return "Salata yap"        # AYNI!

    def make_special_dish(self):
        return "Orange chicken"    # FARKLI

    def make_fried_rice(self):
        return "Pirinc kavur"      # YENI

Çoğu method aynı. Kod tekrarı.

13.5.2 Inheritance ile Çözüm

class Chef:
    def make_chicken(self):
        return "Tavuk pisir"

    def make_salad(self):
        return "Salata yap"

    def make_special_dish(self):
        return "Bbq tavuk"


class ChineseChef(Chef):    # Chef'ten miras al!

    # make_chicken, make_salad otomatik geliyor!

    def make_special_dish(self):    # OVERRIDE
        return "Orange chicken"

    def make_fried_rice(self):      # YENI
        return "Pirinc kavur"

13.5.3 Override

chef = Chef()
chinese = ChineseChef()

print(chef.make_chicken())          # Tavuk pisir
print(chinese.make_chicken())       # Tavuk pisir   (miras)

print(chef.make_special_dish())     # Bbq tavuk
print(chinese.make_special_dish())  # Orange chicken (override)

print(chinese.make_fried_rice())    # Pirinc kavur (yeni)
print(chef.make_fried_rice())       # AttributeError

13.5.4 `super()` ile Parent’a Erişim

class Animal:
    def __init__(self, name):
        self.name = name
        self.alive = True

    def describe(self):
        return f"{self.name} is alive: {self.alive}"


class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)    # Parent'in __init__'ini cagir
        self.breed = breed

    def describe(self):
        parent_desc = super().describe()
        return f"{parent_desc}, breed: {self.breed}"

13.5.5 `isinstance` ile Tip Kontrolü

bobby = Dog("Bobby", "Labrador")

isinstance(bobby, Dog)       # True
isinstance(bobby, Animal)    # True (alt-sinif kontrolu)
isinstance(bobby, str)       # False

ML kodda:

def process_model(model):
    if isinstance(model, nn.Module):
        return model.state_dict()
    elif isinstance(model, dict):
        return model
    else:
        raise TypeError("Unsupported")

13.5.6 PyTorch Inheritance

Builder Notu — class MyBertClassifier(BertModel):

Bütün PyTorch modelleri nn.Module’den inherit eder:

import torch.nn as nn

class MyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(10, 1)

    def forward(self, x):
        return self.fc(x)

# HuggingFace:
from transformers import BertModel

class MyBertClassifier(BertModel):    # BertModel'i inherit
    def __init__(self, config, num_classes):
        super().__init__(config)
        self.classifier = nn.Linear(config.hidden_size, num_classes)

    def forward(self, input_ids, attention_mask=None):
        outputs = super().forward(input_ids, attention_mask=attention_mask)
        return self.classifier(outputs.pooler_output)

class MyBertClassifier(BertModel): — HuggingFace’in milyarlarca parametreli BERT modelinin tüm özelliklerini al, üzerine kendi classifier’ını ekle.

Mosh’un class ChineseChef(Chef): örneği, modern LLM kodlarında tam olarak bu yapıda. Sadece Chef yerine BertModel, make_special_dish yerine forward.

13.6 Special Methods (Dunders)

Mosh göstermez ama modern Python’un en güçlü özelliklerinden.

13.6.1 `str` ve `repr`

class Student:
    def __init__(self, name, gpa):
        self.name = name
        self.gpa = gpa

    def __str__(self):
        return f"Student({self.name}, GPA={self.gpa})"

s = Student("Jim", 3.5)
print(s)        # Student(Jim, GPA=3.5)

13.6.2 `len` ve `getitem`

class Playlist:
    def __init__(self, songs):
        self.songs = songs

    def __len__(self):
        return len(self.songs)

    def __getitem__(self, idx):
        return self.songs[idx]


p = Playlist(["Song 1", "Song 2", "Song 3"])
len(p)        # 3       (__len__ tetiklendi)
p[0]          # Song 1  (__getitem__ tetiklendi)

for song in p:     # iteration otomatik!
    print(song)

Python’un duck typing — sıradan obje birden list gibi davranır.

13.6.3 `call` — Instance’i Çağrılabilir Yap

class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self, increment=1):
        self.count += increment
        return self.count


c = Counter()
print(c())     # 1   (c() __call__'u tetikler!)
print(c())     # 2
print(c(5))    # 7

PyTorch’un kalbi:

model = MyModel()
output = model(x)    # __call__ otomatik forward'i cagirir

13.6.4 Diğer Yararlı Dunders

Dunder	Tetikleyici	Kullanım
`__init__`	`Cls(...)`	Constructor
`__str__`	`str(obj)`, `print`	Human-readable
`__repr__`	`repr(obj)`, REPL	Debug
`__len__`	`len(obj)`	Uzunluk
`__getitem__`	`obj[i]`	Indexing
`__contains__`	`x in obj`	Membership
`__iter__`	`for x in obj:`	Iteration
`__call__`	`obj(...)`	Çağrı
`__eq__`	`==`	Eşitlik
`__add__`	`+`	Toplama
`__enter__`, `__exit__`	`with obj:`	Context manager

Python’un her operatörü bir dunder’a bağlı.

13.6.5 PyTorch Dataset = Dunders

Builder Notu — DataLoader Magic

import torch
from torch.utils.data import Dataset

class MyImageDataset(Dataset):
    def __init__(self, image_paths, labels, transform=None):
        self.image_paths = image_paths
        self.labels = labels
        self.transform = transform

    def __len__(self):                # len(dataset) icin
        return len(self.image_paths)

    def __getitem__(self, idx):       # dataset[i] icin
        path = self.image_paths[idx]
        label = self.labels[idx]

        from PIL import Image
        image = Image.open(path).convert("RGB")

        if self.transform:
            image = self.transform(image)

        return image, label


dataset = MyImageDataset(paths, labels)
print(len(dataset))       # __len__ cagrildi
image, label = dataset[0] # __getitem__ cagrildi

from torch.utils.data import DataLoader
loader = DataLoader(dataset, batch_size=32, shuffle=True)

for batch_images, batch_labels in loader:    # iteration!
    ...

PyTorch’un tüm DataLoader sistemi __len__ ve __getitem__ dunders üzerine kurulu. Mosh göstermez ama bu mekanizma modern ML pipeline’ının temelidir.

Şekil 13.2: Mosh’un Student class’ı → PyTorch nn.Module — sentez

13.7 TAM `nn.Module` — Kursun Sentezi

Bu bölüm Ders 12’nin ve tüm kursun zirvesi. Mosh’un 8 saatte öğrettiği her şey, modern PyTorch model sınıfında birleşiyor.

import torch
import torch.nn as nn
import torch.nn.functional as F


class Transformer(nn.Module):
    """Mini transformer encoder. Mosh'un tum derslerinin sentezi."""

    def __init__(self, vocab_size, d_model=512, n_heads=8, n_layers=6, max_len=128):
        # === Ders 12 (OOP): super, __init__ ===
        super().__init__()

        # === Ders 2 (variables, types) ===
        self.d_model = d_model
        self.n_heads = n_heads

        # === Ders 4 (list, tuple) - ModuleList ===
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.pos_embedding = nn.Embedding(max_len, d_model)

        # === Ders 8 (loop), Ders 12 (inheritance) ===
        self.attention_layers = nn.ModuleList([
            MultiHeadAttention(d_model, n_heads) for _ in range(n_layers)
        ])
        self.ff_layers = nn.ModuleList([
            FeedForward(d_model) for _ in range(n_layers)
        ])

        # === Ders 6 (decision) - condition ile final layer ===
        self.classifier = nn.Linear(d_model, vocab_size)

    def forward(self, x, mask=None):
        """Mosh'un Ders 5 fonksiyonu + Ders 8 dongusu + Ders 12 self."""
        # === Ders 4 (tuple unpacking) ===
        batch, seq_len = x.shape

        # === Ders 2 (arithmetic) ===
        positions = torch.arange(seq_len, device=x.device).unsqueeze(0).expand(batch, -1)

        # === Ders 12 (self.attribute) ===
        x = self.embedding(x) + self.pos_embedding(positions)

        # === Ders 8 (for loop), Ders 12 (zip) ===
        for attn, ff in zip(self.attention_layers, self.ff_layers):
            # === Ders 12 (__call__) - layer(x) ===
            x = x + attn(x, mask)        # residual connection
            x = x + ff(x)

        # === Ders 5 (return) ===
        return self.classifier(x)

    def __repr__(self):
        """Ders 12 (dunder method)."""
        n_params = sum(p.numel() for p in self.parameters())
        return f"Transformer(d_model={self.d_model}, params={n_params:,})"


# === Ders 3 (input, args), Ders 7 (dict config) ===
config = {
    "vocab_size": 50000,
    "d_model": 512,
    "n_heads": 8,
    "n_layers": 6,
}

# === Ders 12 (instantiation) ===
model = Transformer(**config)
print(model)
# Transformer(d_model=512, params=18,832,128)

13.7.1 Mosh’un 8 Saatinin Tek Class’ta Sentezi

Bu tek dosyada:

Ders	Konsept	Yerleşim
1	print, sıralı yürütme	`print(model)`, kodun akışı
2	değişken, tip	`self.d_model = d_model`
3	input → config dict	`Transformer(**config)`
4	list, tuple unpacking	`ModuleList([...])`, `batch, seq_len = x.shape`
5	def, return	`def forward(...)`, `return self.classifier(x)`
6	if, comparison	forward içinde mask kontrolü
7	dict	`config = {...}`, `Transformer(**config)`
8	for, zip	`for attn, ff in zip(...)`
9	docstring/yorum	`"""..."""`, satır yorumları
10	(try/except, with)	production’da olurdu
11	import	`import torch`, `import torch.nn as nn`
12	class, init, self, inheritance, repr	her satır

Bütün kurs, tek class’ta birleşiyor.

13.7.2 `for batch in dataloader` — Modern AI’nın Tek Cümlesi

for batch in dataloader:
    ...

Bu dokuz karakter modern AI’nın çekirdek mantığını taşır. GPT-4 eğitilirken bu satır milyonlarca kez çağrıldı.

13.8 Karpathy’nin minGPT’si

Builder Notu — Sonraki Adım

Andrej Karpathy’nin GPT’yi sıfırdan yazdığı minGPT projesini incelemek istersen, her satırı bu kursta öğrendiğin kavramları kullanır. class GPT(nn.Module):, def __init__, def forward, for layer in self.blocks:, self.attn = MultiHeadAttention(...).

Mosh’un kursunu bitirdikten sonra anlaşılır olacak.

13.9 Bu Dersin Özeti

Class = veri tipi blueprint. PascalCase.
__init__(self, ...) = constructor.
self = instance referansı.
obj = Cls(args) = object yaratma.
obj.attribute = erişim.
def method(self, ...) = method.
class Child(Parent): = inheritance.
super().__init__(...) = parent constructor.
Dunders __str__, __len__, __getitem__, __call__.
isinstance(obj, Cls) = tip kontrolü.
class MyModel(nn.Module): = modern AI’nın temeli.

Tek Bir Cümle

Class Python’da kendi veri tipini yaratmanı sağlar — Mosh’un class Student: mikro örneği, modern AI’nın class Transformer(nn.Module): mimarisinin birebir aynı yapıdaki atasıdır; __init__ constructor, self.attribute = value instance state, methods (def forward(self, x):), inheritance (class MyModel(BertModel):), special methods (__call__ → model(x), __getitem__ → dataset[i]) — Python OOP’nin tüm kavramları PyTorch’un, transformers’ın, ve modern LLM kodlarının yapı taşlarıdır; Mosh’un sekiz saatlik kursunda öğrettiği her şey bir class Model(nn.Module): def forward(self, x): ... deyiminde sentez bulur — ve bu noktadan sonra Karpathy’nin minGPT’sini, Hugging Face transformers’ı, PyTorch tutorial’larını okuduğunda sana hiç yabancı gelmeyecek.

13.10 🎓 Kurs Sonu — Mosh’un Sekiz Saatinin Sentezi

Bu Mosh Hamedani’nin Python for Beginners kursunun son dersi.

13.10.1 Kursun 12 Dersinin Final Sentezi

Ders	Konu	ML Köprüsü
1	Kurulum	Python = ML lingua franca
2	Değişkenler	str/int/float = tensor dtype
3	Girdi	LLM prompt template’in atası
4	Listeler ve Tuple	ndarray = Tensor
5	Fonksiyonlar	`nn.Module.forward()`
6	Karar Yapıları	`torch.where`, attention masking
7	Sözlükler/Setler	state_dict, NLP vocabulary
8	Döngüler	`for batch in dataloader` ⭐
9	Çevirmen + Yorum	NLP preprocessing, ML docs
10	Hata + Dosyalar	NaN guard, checkpoint persistence
11	Modüller + Pip	ML kütüphane evrenine kapı
12	OOP	`class MyModel(nn.Module):` ⭐

13.10.2 Şimdi Ne Yap?

1. Pratik:

Bu kursun egzersizlerini bitir.
5-10 küçük Python projesi yaz.
Kod kıracak — bu iyidir.

2. ML evrenine giriş:

pip install numpy pandas matplotlib scikit-learn jupyter.
Jupyter notebook’ta gez.
Kaggle’da bir başlangıç kompetisyonu.

3. Derin öğrenme:

pip install torch torchvision.
PyTorch’un 60-minute blitz.
Karpathy’nin Zero to Hero.

4. LLM evreni:

pip install transformers.
Hugging Face Course.
Karpathy’nin minGPT projesi.

5. Kardeş kurslar:

Phase 1 serisi:

📐 MIT 18.06 — Linear Algebra
🎲 Harvard Stat 110 — Probability
🔵 3Blue1Brown — Calculus
🧠 MIT 6.S191 — Deep Learning

13.11 Egzersizler

Egzersiz 1. Student class + method:

class Student:
    def __init__(self, name, major, gpa):
        ???

    def on_honor_roll(self):
        return ???

    def status(self):
        if self.gpa >= 3.5:
            return f"{self.name} (honor roll)"
        elif self.gpa >= 2.0:
            return f"{self.name} (regular)"
        else:
            return f"{self.name} (probation)"

Egzersiz 2. BankAccount + try/except:

class BankAccount:
    def __init__(self, owner, balance=0):
        ???

    def deposit(self, amount):
        """amount <= 0 ise ValueError."""
        ???

    def withdraw(self, amount):
        """Yetersiz bakiye -> ValueError."""
        ???

    def transfer(self, other, amount):
        ???

Egzersiz 3. Inheritance — Animal / Dog / Cat:

class Animal:
    def __init__(self, name, age):
        ???

class Dog(Animal):
    def __init__(self, name, age, breed):
        super().???
        self.breed = breed

    def speak(self):
        return f"{self.name}: Woof!"

class Cat(Animal):
    def __init__(self, name, age, indoor=True):
        super().???
        self.indoor = indoor

    def speak(self):
        return f"{self.name}: Meow!"

Egzersiz 4. Vector2D + dunders (+, -, *, ==):

import math

class Vector2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return ???

    def __mul__(self, scalar):
        return ???

    def __eq__(self, other):
        return ???

    def __str__(self):
        return f"Vector2D({self.x}, {self.y})"

    def magnitude(self):
        return math.sqrt(self.x**2 + self.y**2)

NumPy/PyTorch tensor matematik operatörlerinin ilkel versiyonu.

Egzersiz 5. (FİNAL — mini Model hiyerarşisi)

class Model:
    def __init__(self, name):
        self.name = name
        self.trained = False

    def train(self, data):
        raise NotImplementedError

    def predict(self, x):
        raise NotImplementedError

    def __repr__(self):
        return f"{self.__class__.__name__}(name={self.name!r}, trained={self.trained})"


class LinearModel(Model):
    def __init__(self, name="Linear"):
        super().???
        self.m = None
        self.b = None

    def train(self, data):
        # Basit lineer regresyon
        xs = [x for x, _ in data]
        ys = [y for _, y in data]
        n = len(data)
        x_mean = sum(xs) / n
        y_mean = sum(ys) / n
        # Egim:
        num = sum((x - x_mean) * (y - y_mean) for x, y in data)
        den = sum((x - x_mean) ** 2 for x in xs)
        self.m = num / den
        self.b = y_mean - self.m * x_mean
        self.trained = True

    def predict(self, x):
        if not self.trained:
            raise RuntimeError("Henuz egitilmedi")
        return self.m * x + self.b


# Test:
data = [(1, 2), (2, 4), (3, 6), (4, 8)]   # y = 2x

lin = LinearModel()
lin.train(data)
print(lin)                # LinearModel(name='Linear', trained=True)
print(lin.predict(5))     # ~10 (y = 2*5)

Bu egzersiz scikit-learn API’sinin mini hâlidir. Mosh’un öğrettiği OOP, gerçek ML kütüphanelerinin çekirdek API tasarımıdır.

🎓 Bu kursun final cümlesi

Mosh’un Ders 1’de “Python öğrenmek = ML ekosisteminin bilet kasasına girmek” dediğimiz şey artık gerçek. Ders 2’de değişken, Ders 3’te input, Ders 4’te list/tuple, Ders 5’te fonksiyon, Ders 6’da if/else, Ders 7’de dict, Ders 8’de for-batch-in-dataloader, Ders 9’da preprocessing, Ders 10’da defansif kod, Ders 11’de pip install, ve Ders 12’de class — her satır seninle bugünden itibaren modern AI mühendisliği yolunda. class MyModel(nn.Module): def __init__(self): super().__init__(); self.layer = nn.Linear(...); def forward(self, x): return self.layer(x) artık sana yabancı değil — Mosh’un öğrettiği class Student: def __init__(self, name): self.name = name; def graduate(self): return f"{self.name} mezun oldu" ile birebir aynı yapı, sadece tensor ve gradient katılmış. Sonraki adım: pip install torch transformers, ve Karpathy’nin minGPT’sine git. Mosh’un sekiz saat boyunca öğrettiği her temel kavram, modern AI’nın yapı taşıdır — ve sen artık bunları biliyorsun.

--- title: "Nesne Yönelimli Programlama (OOP)" subtitle: "`class MyModel(nn.Module):` — modern AI'nın DNA'sı" --- ::: {.callout-note title="Bölüm bilgisi"} - **Mosh'un videosu:** [Chapters 31-34 (Classes → Quiz → Methods → Inheritance)](https://www.youtube.com/watch?v=rfscVS0vtbw&t=13438s) (≈37 dk) - **Bölüm aralığı:** 3:43:58 — 4:20:46 - **Kaynaklar:** [Python docs — classes](https://docs.python.org/3/tutorial/classes.html) · [PyTorch nn.Module](https://pytorch.org/docs/stable/generated/torch.nn.Module.html) · [PEP 8 — class names](https://peps.python.org/pep-0008/#class-names) - **Okuma süresi:** ≈60 dk ::: ## Bu Derste Ne Var? — KURSUN FİNALİ {#sec-bu-derste-12} Bu kursun **son** dersi. Mosh'un başlangıçtan beri öğrettiklerini bir araya toplayıp **modern Python'un** en güçlü kavramına ulaşıyoruz: **nesne yönelimli programlama (OOP)** ve **class'lar**. Bu, aynı zamanda **modern AI'nın yapı taşlarının** oturduğu yerdir. PyTorch'taki `class MyModel(nn.Module):` deyimi — GPT-4'ün, Stable Diffusion'ın, Claude'un, BERT'in tümünün çekirdeği — tam bu derste öğreneceğimiz kavramın uygulamasıdır. ```{mermaid} %%| label: fig-akis-12 %%| fig-cap: "Ders 12'nin akış haritası — class'tan nn.Module'e ve kurs sonuna" flowchart LR A["class Student:"] --> B["__init__ + self"] B --> C["Object yaratma"] C --> D["Methods"] D --> E["Inheritance"] E --> F["Dunders<br/>__call__, __getitem__"] F --> G["💎 class MyModel(nn.Module):"] G --> H["⚡ MODERN AI'NIN DNA'sı"] style G fill:#fff3e0,stroke:#f57c00,stroke-width:2px style H fill:#ffcdd2,stroke:#b71c1c,stroke-width:3px ``` **Dersin yedi parçası:** 1. **Class motivasyonu.** — Gerçek dünyayı modellemek. 2. **`class` + `__init__` + `self`.** 3. **Object yaratma + attribute erişim.** 4. **Methods.** 5. **Inheritance.** 6. **Special methods (dunders).** 7. **`nn.Module` — TAM ML sınıfı.** ::: {.callout-tip title="Builder Notu — KURSUN FİNALİ (en derin köprüler)"} - **`class MyModel(nn.Module):` = modern AI'nın DNA'sı.** Her sinir ağı, her LLM, her görüntü sınıflandırma bu pattern üzerine kurulu. - **`def __init__(self, ...):` = layer setup.** PyTorch'ta `self.layer1 = nn.Linear(...)`. - **`def forward(self, x):` = computation graph.** Modelin verisini girdi-çıktı zincirine dönüştürür. - **Inheritance: `class MyModel(nn.Module):` = AI mimari mirası.** `nn.Module`'ün tüm özelliklerini al. - **`self` = state encapsulation.** Mosh'un "object'in kendi referansı" PyTorch'ta `self.layers` ile model içi state. - **`super().__init__()` = parent constructor.** PyTorch'ta **zorunlu**. - **Special methods (dunders) = Python'un gücü.** `__call__` → `model(x)`. `__len__` → `len(dataset)`. `__getitem__` → `dataset[i]`. PyTorch DataLoader API'si bu dunders üzerine. ::: ## Class Motivasyonu {#sec-motivasyon} Mosh: > *"çok var Bir dize ya da diziyi otomatikleştirmede gerçek dünyada temsil edemediğimiz şeyleri"* — Mosh (Türkçe dublaj), 3:44:53 ### Python'un Sınırlı Tipleri Şimdiye kadar: - `int`, `float`, `str`, `bool`, `list`, `tuple`, `dict`, `set`. Bunlar **soyut**. Gerçek dünyada: - **Öğrenci** — ad, yaş, GPA, bölüm, davranışlar (kayıt ol, mezun ol). - **Ürün** — ad, fiyat, stok. - **Sinir ağı** — katmanlar, parametreler, forward davranışı, training/eval modu. Tek bir `int` veya `string` ile temsil edemeyiz. ### Çözüm — Kendi Veri Tipi > *"sınıflarla ve nesnelerle neler yapabileceğimizi temelde kendimizinkini yaratabiliriz veri tipleri."* — Mosh (Türkçe dublaj), 3:45:15 Class ile **kendi veri tipini** tanımlarsın: ```python class Student: pass # geçici - boş class ``` Şimdi `Student` Python'un **yeni bir tipi**. ### Class vs Object > *"a class is just like an overview of what the student data type is bir obje is an actual student"* — Mosh (Türkçe dublaj), 3:51:05 - **Class** = blueprint, kalıp. - **Object** (instance) = somut bir örnek. Analoji: - Class `Student` = "öğrencinin ne olduğunu tanımlayan teorik kalıp". - Object `student1 = Student("Jim", ...)` = gerçek bir öğrenci. ### Class ML'de ::: {.callout-tip title="Builder Notu — Blueprint → Object"} ```python import torch.nn as nn # Class - blueprint: class MyMLP(nn.Module): def __init__(self, input_dim, hidden_dim, output_dim): super().__init__() self.layer1 = nn.Linear(input_dim, hidden_dim) self.relu = nn.ReLU() self.layer2 = nn.Linear(hidden_dim, output_dim) def forward(self, x): x = self.layer1(x) x = self.relu(x) x = self.layer2(x) return x # Object - actual model: model_a = MyMLP(input_dim=784, hidden_dim=128, output_dim=10) model_b = MyMLP(input_dim=512, hidden_dim=256, output_dim=10) # 3 farkli model, ayni class blueprint'inden ``` Mosh'un "farklı öğrenciler yarat" mantığı = ML'de **farklı model konfigürasyonları**. ::: ## `class`, `__init__`, `self` {#sec-class-init} ### Class Tanımı > *"way that I can do that is just by typing sınıf."* — Mosh (Türkçe dublaj), 3:46:43 ```python class Student: pass ``` **İsimlendirme:** Class adları `PascalCase`. `Student`, `NeuralNetwork`, `BertTokenizer`. ### `__init__` Constructor > *"I want to create something called an initialize işlevi."* — Mosh (Türkçe dublaj), 3:47:40 ```python class Student: def __init__(self, name, major, gpa, is_on_probation): self.name = name self.major = major self.gpa = gpa self.is_on_probation = is_on_probation ``` **`__init__`** (init — initialize) = Python'un **constructor**'ı. Otomatik çağrılır. İki alt çizgi (`__`) — "dunder" (double underscore) — Python'a özel anlam. ### `self` — Instance Referansı **`self`** her method'un **ilk parametresidir**. Object'in **kendi kendine referansı**. ```python def __init__(self, name, major, gpa, is_on_probation): self.name = name # bu instance'in adi ... ``` C++/Java'da `this`; Python'da `self`. ### Object Yaratma ```python # student.py class Student: def __init__(self, name, major, gpa, is_on_probation): self.name = name self.major = major self.gpa = gpa self.is_on_probation = is_on_probation # app.py from student import Student student1 = Student("Jim", "Business", 3.1, False) ``` **Akış:** 1. `Student("Jim", "Business", 3.1, False)` çağrısı. 2. Python yeni `Student` instance yaratır. 3. `__init__(self, "Jim", "Business", 3.1, False)` çağrılır. 4. `__init__` içinde `self.name = "Jim"` ... 5. Tamamlanan instance `student1`'e atanır. `self` parametresi **çağrıda yazılmaz** — Python otomatik geçirir. ### Attribute Erişim ```python student1 = Student("Jim", "Business", 3.1, False) print(student1.name) # Jim print(student1.major) # Business print(student1.gpa) # 3.1 print(student1.is_on_probation) # False ``` ### PyTorch'ta `__init__` ::: {.callout-important title="Builder Notu — Modelin İskeleti"} ```python import torch.nn as nn class SimpleClassifier(nn.Module): def __init__(self, input_dim, num_classes): super().__init__() # nn.Module __init__'ini cagir self.feature_extractor = nn.Sequential( nn.Linear(input_dim, 256), nn.ReLU(), nn.Linear(256, 128), nn.ReLU(), ) self.classifier = nn.Linear(128, num_classes) def forward(self, x): features = self.feature_extractor(x) return self.classifier(features) model = SimpleClassifier(input_dim=784, num_classes=10) print(model.classifier) # Linear layer ``` Mosh'un `self.name = name` öğretişi, PyTorch'ta `self.layer = nn.Linear(...)` ile **birebir** aynı yapı. Sadece `name` yerine katman, katmanlar autograd ile gradient hesabına dahil. **`super().__init__()`** modern Python OOP'sinin standart deyimi. PyTorch'ta **zorunlu**. ::: ## Methods — Class İçinde Fonksiyonlar {#sec-methods} Object **veri** taşımakla kalmaz, **iş** de yapar. ### Method Tanımı ```python class Student: def __init__(self, name, major, gpa, is_on_probation): self.name = name self.major = major self.gpa = gpa self.is_on_probation = is_on_probation def on_honor_roll(self): """GPA 3.5+ ise honor roll'da.""" return self.gpa >= 3.5 def graduate(self): """Mezuniyet acıklaması.""" if self.gpa < 2.0: return f"{self.name} mezun olamaz - GPA dusuk" elif self.is_on_probation: return f"{self.name} probation'da" else: return f"Tebrikler {self.name}!" ``` **Method = class içinde tanımlı fonksiyon.** İlk parametre `self`. ### Method Çağrısı ```python student1 = Student("Jim", "Business", 3.6, False) print(student1.on_honor_roll()) # True print(student1.graduate()) # Tebrikler Jim! ``` `student1.on_honor_roll()` aslında `Student.on_honor_roll(student1)` — Python `student1`'i `self` olarak geçirir. ### Method'lar Argüman Alabilir ```python class BankAccount: def __init__(self, owner, balance=0): self.owner = owner self.balance = balance def deposit(self, amount): if amount <= 0: raise ValueError("Amount must be positive") self.balance += amount return self.balance def withdraw(self, amount): if amount > self.balance: raise ValueError("Insufficient funds") self.balance -= amount return self.balance def transfer(self, other, amount): self.withdraw(amount) other.deposit(amount) deniz = BankAccount("Deniz", 1000) aylin = BankAccount("Aylin", 500) deniz.transfer(aylin, 300) print(deniz.balance) # 700 print(aylin.balance) # 800 ``` ### PyTorch'ta `forward()` ::: {.callout-tip title="Builder Notu — Transformer Forward"} ```python class MultiHeadAttention(nn.Module): def __init__(self, d_model, n_heads): super().__init__() self.d_model = d_model self.n_heads = n_heads self.W_q = nn.Linear(d_model, d_model) self.W_k = nn.Linear(d_model, d_model) self.W_v = nn.Linear(d_model, d_model) self.W_o = nn.Linear(d_model, d_model) def forward(self, x, mask=None): """Tek bir attention block forward.""" Q = self.W_q(x) K = self.W_k(x) V = self.W_v(x) scores = (Q @ K.transpose(-2, -1)) / (self.d_model ** 0.5) if mask is not None: scores = scores.masked_fill(mask == 0, float('-inf')) attn = scores.softmax(dim=-1) return self.W_o(attn @ V) ``` `forward` PyTorch'un **en önemli method'u**. Mosh'un `student.on_honor_roll()` mantığı, transformer'ın `model.forward(x)` mantığıyla **birebir aynı yapıda**: instance state'i kullanarak (`self.W_q`, `self.gpa`) bir hesaplama yap. ::: ## Inheritance — Class'tan Class Türetmek {#sec-inheritance} ### Motivasyon ```python class Chef: def make_chicken(self): return "Tavuk pisir" def make_salad(self): return "Salata yap" def make_special_dish(self): return "Bbq tavuk" class ChineseChef: def make_chicken(self): return "Tavuk pisir" # AYNI Chef'le! def make_salad(self): return "Salata yap" # AYNI! def make_special_dish(self): return "Orange chicken" # FARKLI def make_fried_rice(self): return "Pirinc kavur" # YENI ``` Çoğu method **aynı**. Kod tekrarı. ### Inheritance ile Çözüm ```python class Chef: def make_chicken(self): return "Tavuk pisir" def make_salad(self): return "Salata yap" def make_special_dish(self): return "Bbq tavuk" class ChineseChef(Chef): # Chef'ten miras al! # make_chicken, make_salad otomatik geliyor! def make_special_dish(self): # OVERRIDE return "Orange chicken" def make_fried_rice(self): # YENI return "Pirinc kavur" ``` ### Override ```python chef = Chef() chinese = ChineseChef() print(chef.make_chicken()) # Tavuk pisir print(chinese.make_chicken()) # Tavuk pisir (miras) print(chef.make_special_dish()) # Bbq tavuk print(chinese.make_special_dish()) # Orange chicken (override) print(chinese.make_fried_rice()) # Pirinc kavur (yeni) print(chef.make_fried_rice()) # AttributeError ``` ### `super()` ile Parent'a Erişim ```python class Animal: def __init__(self, name): self.name = name self.alive = True def describe(self): return f"{self.name} is alive: {self.alive}" class Dog(Animal): def __init__(self, name, breed): super().__init__(name) # Parent'in __init__'ini cagir self.breed = breed def describe(self): parent_desc = super().describe() return f"{parent_desc}, breed: {self.breed}" ``` ### `isinstance` ile Tip Kontrolü ```python bobby = Dog("Bobby", "Labrador") isinstance(bobby, Dog) # True isinstance(bobby, Animal) # True (alt-sinif kontrolu) isinstance(bobby, str) # False ``` ML kodda: ```python def process_model(model): if isinstance(model, nn.Module): return model.state_dict() elif isinstance(model, dict): return model else: raise TypeError("Unsupported") ``` ### PyTorch Inheritance ::: {.callout-tip title="Builder Notu — `class MyBertClassifier(BertModel):`"} Bütün PyTorch modelleri `nn.Module`'den inherit eder: ```python import torch.nn as nn class MyModel(nn.Module): def __init__(self): super().__init__() self.fc = nn.Linear(10, 1) def forward(self, x): return self.fc(x) # HuggingFace: from transformers import BertModel class MyBertClassifier(BertModel): # BertModel'i inherit def __init__(self, config, num_classes): super().__init__(config) self.classifier = nn.Linear(config.hidden_size, num_classes) def forward(self, input_ids, attention_mask=None): outputs = super().forward(input_ids, attention_mask=attention_mask) return self.classifier(outputs.pooler_output) ``` `class MyBertClassifier(BertModel):` — HuggingFace'in **milyarlarca parametreli** BERT modelinin tüm özelliklerini al, üzerine kendi classifier'ını ekle. Mosh'un `class ChineseChef(Chef):` örneği, modern LLM kodlarında **tam olarak bu yapıda**. Sadece `Chef` yerine `BertModel`, `make_special_dish` yerine `forward`. ::: ## Special Methods (Dunders) {#sec-dunders} Mosh göstermez ama modern Python'un en güçlü özelliklerinden. ### `__str__` ve `__repr__` ```python class Student: def __init__(self, name, gpa): self.name = name self.gpa = gpa def __str__(self): return f"Student({self.name}, GPA={self.gpa})" s = Student("Jim", 3.5) print(s) # Student(Jim, GPA=3.5) ``` ### `__len__` ve `__getitem__` ```python class Playlist: def __init__(self, songs): self.songs = songs def __len__(self): return len(self.songs) def __getitem__(self, idx): return self.songs[idx] p = Playlist(["Song 1", "Song 2", "Song 3"]) len(p) # 3 (__len__ tetiklendi) p[0] # Song 1 (__getitem__ tetiklendi) for song in p: # iteration otomatik! print(song) ``` **Python'un duck typing** — sıradan obje birden list gibi davranır. ### `__call__` — Instance'i Çağrılabilir Yap ```python class Counter: def __init__(self): self.count = 0 def __call__(self, increment=1): self.count += increment return self.count c = Counter() print(c()) # 1 (c() __call__'u tetikler!) print(c()) # 2 print(c(5)) # 7 ``` PyTorch'un kalbi: ```python model = MyModel() output = model(x) # __call__ otomatik forward'i cagirir ``` ### Diğer Yararlı Dunders | Dunder | Tetikleyici | Kullanım | |---|---|---| | `__init__` | `Cls(...)` | Constructor | | `__str__` | `str(obj)`, `print` | Human-readable | | `__repr__` | `repr(obj)`, REPL | Debug | | `__len__` | `len(obj)` | Uzunluk | | `__getitem__` | `obj[i]` | Indexing | | `__contains__` | `x in obj` | Membership | | `__iter__` | `for x in obj:` | Iteration | | `__call__` | `obj(...)` | Çağrı | | `__eq__` | `==` | Eşitlik | | `__add__` | `+` | Toplama | | `__enter__`, `__exit__` | `with obj:` | Context manager | Python'un her operatörü bir dunder'a bağlı. ### PyTorch Dataset = Dunders ::: {.callout-important title="Builder Notu — DataLoader Magic"} ```python import torch from torch.utils.data import Dataset class MyImageDataset(Dataset): def __init__(self, image_paths, labels, transform=None): self.image_paths = image_paths self.labels = labels self.transform = transform def __len__(self): # len(dataset) icin return len(self.image_paths) def __getitem__(self, idx): # dataset[i] icin path = self.image_paths[idx] label = self.labels[idx] from PIL import Image image = Image.open(path).convert("RGB") if self.transform: image = self.transform(image) return image, label dataset = MyImageDataset(paths, labels) print(len(dataset)) # __len__ cagrildi image, label = dataset[0] # __getitem__ cagrildi from torch.utils.data import DataLoader loader = DataLoader(dataset, batch_size=32, shuffle=True) for batch_images, batch_labels in loader: # iteration! ... ``` PyTorch'un **tüm** DataLoader sistemi `__len__` ve `__getitem__` dunders üzerine kurulu. Mosh göstermez ama bu mekanizma modern ML pipeline'ının temelidir. ::: ```{python} #| label: fig-class-evolution #| fig-cap: "Mosh'un Student class'ı → PyTorch nn.Module — sentez" #| fig-width: 11 #| fig-height: 5 import matplotlib.pyplot as plt import matplotlib.patches as patches fig, ax = plt.subplots(figsize=(11, 5)) # Mosh tarafı mosh_box = patches.FancyBboxPatch((0.02, 0.15), 0.42, 0.75, boxstyle="round,pad=0.02", edgecolor="#3776ab", facecolor="#e3f2fd", linewidth=2.5) ax.add_patch(mosh_box) ax.text(0.23, 0.84, "Mosh's Student", ha="center", fontsize=13, fontweight="bold", color="#1a3a5c") mosh_code = [ "class Student:", " def __init__(self, name, gpa):", " self.name = name", " self.gpa = gpa", " ", " def graduate(self):", " return f\"{self.name} mezun!\"", "", "s = Student(\"Jim\", 3.5)", "print(s.name) # Jim", "print(s.graduate()) # Jim mezun!", ] for i, line in enumerate(mosh_code): ax.text(0.04, 0.74 - i*0.052, line, fontsize=9.5, family="monospace", color="#1a3a5c") # Arrow ax.annotate("", xy=(0.55, 0.55), xytext=(0.46, 0.55), arrowprops=dict(arrowstyle="->", lw=3, color="#f57c00")) ax.text(0.5, 0.6, "AYNI", ha="center", fontsize=11, color="#f57c00", fontweight="bold") ax.text(0.5, 0.50, "YAPI", ha="center", fontsize=11, color="#f57c00", fontweight="bold") # PyTorch tarafı pt_box = patches.FancyBboxPatch((0.56, 0.15), 0.42, 0.75, boxstyle="round,pad=0.02", edgecolor="#c2185b", facecolor="#fce4ec", linewidth=2.5) ax.add_patch(pt_box) ax.text(0.77, 0.84, "PyTorch nn.Module", ha="center", fontsize=13, fontweight="bold", color="#c2185b") pt_code = [ "class MyModel(nn.Module):", " def __init__(self):", " super().__init__()", " self.layer = nn.Linear(10, 1)", " ", " def forward(self, x):", " return self.layer(x)", "", "model = MyModel()", "out = model(x) # __call__", "print(model.layer) # Linear", ] for i, line in enumerate(pt_code): ax.text(0.58, 0.74 - i*0.052, line, fontsize=9.5, family="monospace", color="#1a3a5c") ax.text(0.5, 0.07, "Mosh'un `class Student:` → PyTorch'un `class MyModel(nn.Module):`", ha="center", fontsize=11, style="italic", color="#4a5568") ax.set_xlim(0, 1); ax.set_ylim(0, 1) ax.axis("off") plt.tight_layout() plt.show() ``` ## TAM `nn.Module` — Kursun Sentezi {#sec-sentez} Bu bölüm Ders 12'nin **ve tüm kursun** zirvesi. Mosh'un 8 saatte öğrettiği her şey, modern PyTorch model sınıfında birleşiyor. ```python import torch import torch.nn as nn import torch.nn.functional as F class Transformer(nn.Module): """Mini transformer encoder. Mosh'un tum derslerinin sentezi.""" def __init__(self, vocab_size, d_model=512, n_heads=8, n_layers=6, max_len=128): # === Ders 12 (OOP): super, __init__ === super().__init__() # === Ders 2 (variables, types) === self.d_model = d_model self.n_heads = n_heads # === Ders 4 (list, tuple) - ModuleList === self.embedding = nn.Embedding(vocab_size, d_model) self.pos_embedding = nn.Embedding(max_len, d_model) # === Ders 8 (loop), Ders 12 (inheritance) === self.attention_layers = nn.ModuleList([ MultiHeadAttention(d_model, n_heads) for _ in range(n_layers) ]) self.ff_layers = nn.ModuleList([ FeedForward(d_model) for _ in range(n_layers) ]) # === Ders 6 (decision) - condition ile final layer === self.classifier = nn.Linear(d_model, vocab_size) def forward(self, x, mask=None): """Mosh'un Ders 5 fonksiyonu + Ders 8 dongusu + Ders 12 self.""" # === Ders 4 (tuple unpacking) === batch, seq_len = x.shape # === Ders 2 (arithmetic) === positions = torch.arange(seq_len, device=x.device).unsqueeze(0).expand(batch, -1) # === Ders 12 (self.attribute) === x = self.embedding(x) + self.pos_embedding(positions) # === Ders 8 (for loop), Ders 12 (zip) === for attn, ff in zip(self.attention_layers, self.ff_layers): # === Ders 12 (__call__) - layer(x) === x = x + attn(x, mask) # residual connection x = x + ff(x) # === Ders 5 (return) === return self.classifier(x) def __repr__(self): """Ders 12 (dunder method).""" n_params = sum(p.numel() for p in self.parameters()) return f"Transformer(d_model={self.d_model}, params={n_params:,})" # === Ders 3 (input, args), Ders 7 (dict config) === config = { "vocab_size": 50000, "d_model": 512, "n_heads": 8, "n_layers": 6, } # === Ders 12 (instantiation) === model = Transformer(**config) print(model) # Transformer(d_model=512, params=18,832,128) ``` ### Mosh'un 8 Saatinin Tek Class'ta Sentezi Bu **tek dosyada**: | Ders | Konsept | Yerleşim | |------|---------|----------| | 1 | print, sıralı yürütme | `print(model)`, kodun akışı | | 2 | değişken, tip | `self.d_model = d_model` | | 3 | input → config dict | `Transformer(**config)` | | 4 | list, tuple unpacking | `ModuleList([...])`, `batch, seq_len = x.shape` | | 5 | def, return | `def forward(...)`, `return self.classifier(x)` | | 6 | if, comparison | forward içinde mask kontrolü | | 7 | dict | `config = {...}`, `Transformer(**config)` | | 8 | for, zip | `for attn, ff in zip(...)` | | 9 | docstring/yorum | `"""..."""`, satır yorumları | | 10 | (try/except, with) | production'da olurdu | | 11 | import | `import torch`, `import torch.nn as nn` | | 12 | class, __init__, self, inheritance, __repr__ | **her satır** | **Bütün kurs, tek class'ta birleşiyor.** ### `for batch in dataloader` — Modern AI'nın Tek Cümlesi ```python for batch in dataloader: ... ``` Bu **dokuz karakter** modern AI'nın çekirdek mantığını taşır. GPT-4 eğitilirken bu satır milyonlarca kez çağrıldı. ## Karpathy'nin minGPT'si ::: {.callout-tip title="Builder Notu — Sonraki Adım"} Andrej Karpathy'nin GPT'yi sıfırdan yazdığı [`minGPT`](https://github.com/karpathy/minGPT) projesini incelemek istersen, **her satırı** bu kursta öğrendiğin kavramları kullanır. `class GPT(nn.Module):`, `def __init__`, `def forward`, `for layer in self.blocks:`, `self.attn = MultiHeadAttention(...)`. Mosh'un kursunu bitirdikten sonra **anlaşılır olacak**. ::: ## Bu Dersin Özeti {#sec-ozet-12} 1. **Class** = veri tipi blueprint. PascalCase. 2. **`__init__(self, ...)`** = constructor. 3. **`self`** = instance referansı. 4. **`obj = Cls(args)`** = object yaratma. 5. **`obj.attribute`** = erişim. 6. **`def method(self, ...)`** = method. 7. **`class Child(Parent):`** = inheritance. 8. **`super().__init__(...)`** = parent constructor. 9. **Dunders** `__str__`, `__len__`, `__getitem__`, `__call__`. 10. **`isinstance(obj, Cls)`** = tip kontrolü. 11. **`class MyModel(nn.Module):`** = modern AI'nın temeli. ::: {.callout-important title="Tek Bir Cümle"} Class Python'da kendi veri tipini yaratmanı sağlar — Mosh'un `class Student:` mikro örneği, modern AI'nın `class Transformer(nn.Module):` mimarisinin **birebir** aynı yapıdaki atasıdır; `__init__` constructor, `self.attribute = value` instance state, methods (`def forward(self, x):`), inheritance (`class MyModel(BertModel):`), special methods (`__call__` → `model(x)`, `__getitem__` → `dataset[i]`) — Python OOP'nin tüm kavramları PyTorch'un, transformers'ın, ve modern LLM kodlarının yapı taşlarıdır; Mosh'un sekiz saatlik kursunda öğrettiği **her şey** bir `class Model(nn.Module): def forward(self, x): ...` deyiminde sentez bulur — ve bu noktadan sonra Karpathy'nin minGPT'sini, Hugging Face transformers'ı, PyTorch tutorial'larını okuduğunda **sana hiç yabancı gelmeyecek**. ::: ## 🎓 Kurs Sonu — Mosh'un Sekiz Saatinin Sentezi {#sec-kurs-sonu} Bu Mosh Hamedani'nin Python for Beginners kursunun **son** dersi. ### Kursun 12 Dersinin Final Sentezi | Ders | Konu | ML Köprüsü | |---|---|---| | 1 | Kurulum | Python = ML lingua franca | | 2 | Değişkenler | str/int/float = tensor dtype | | 3 | Girdi | LLM prompt template'in atası | | 4 | Listeler ve Tuple | ndarray = Tensor | | 5 | Fonksiyonlar | `nn.Module.forward()` | | 6 | Karar Yapıları | `torch.where`, attention masking | | 7 | Sözlükler/Setler | state_dict, NLP vocabulary | | 8 | Döngüler | `for batch in dataloader` ⭐ | | 9 | Çevirmen + Yorum | NLP preprocessing, ML docs | | 10 | Hata + Dosyalar | NaN guard, checkpoint persistence | | 11 | Modüller + Pip | ML kütüphane evrenine kapı | | 12 | OOP | `class MyModel(nn.Module):` ⭐ | ### Şimdi Ne Yap? **1. Pratik:** - Bu kursun egzersizlerini bitir. - 5-10 küçük Python projesi yaz. - Kod kıracak — bu **iyidir**. **2. ML evrenine giriş:** - `pip install numpy pandas matplotlib scikit-learn jupyter`. - Jupyter notebook'ta gez. - Kaggle'da bir başlangıç kompetisyonu. **3. Derin öğrenme:** - `pip install torch torchvision`. - PyTorch'un [60-minute blitz](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html). - Karpathy'nin [Zero to Hero](https://karpathy.ai/zero-to-hero.html). **4. LLM evreni:** - `pip install transformers`. - Hugging Face Course. - Karpathy'nin [minGPT](https://github.com/karpathy/minGPT) projesi. **5. Kardeş kurslar:** Phase 1 serisi: - 📐 MIT 18.06 — Linear Algebra - 🎲 Harvard Stat 110 — Probability - 🔵 3Blue1Brown — Calculus - 🧠 MIT 6.S191 — Deep Learning ## Egzersizler {#sec-egzersizler-12} **Egzersiz 1.** Student class + method: ```python class Student: def __init__(self, name, major, gpa): ??? def on_honor_roll(self): return ??? def status(self): if self.gpa >= 3.5: return f"{self.name} (honor roll)" elif self.gpa >= 2.0: return f"{self.name} (regular)" else: return f"{self.name} (probation)" ``` **Egzersiz 2.** BankAccount + try/except: ```python class BankAccount: def __init__(self, owner, balance=0): ??? def deposit(self, amount): """amount <= 0 ise ValueError.""" ??? def withdraw(self, amount): """Yetersiz bakiye -> ValueError.""" ??? def transfer(self, other, amount): ??? ``` **Egzersiz 3.** Inheritance — Animal / Dog / Cat: ```python class Animal: def __init__(self, name, age): ??? class Dog(Animal): def __init__(self, name, age, breed): super().??? self.breed = breed def speak(self): return f"{self.name}: Woof!" class Cat(Animal): def __init__(self, name, age, indoor=True): super().??? self.indoor = indoor def speak(self): return f"{self.name}: Meow!" ``` **Egzersiz 4.** Vector2D + dunders (`+`, `-`, `*`, `==`): ```python import math class Vector2D: def __init__(self, x, y): self.x = x self.y = y def __add__(self, other): return ??? def __mul__(self, scalar): return ??? def __eq__(self, other): return ??? def __str__(self): return f"Vector2D({self.x}, {self.y})" def magnitude(self): return math.sqrt(self.x**2 + self.y**2) ``` NumPy/PyTorch tensor matematik operatörlerinin ilkel versiyonu. **Egzersiz 5.** (FİNAL — mini Model hiyerarşisi) ```python class Model: def __init__(self, name): self.name = name self.trained = False def train(self, data): raise NotImplementedError def predict(self, x): raise NotImplementedError def __repr__(self): return f"{self.__class__.__name__}(name={self.name!r}, trained={self.trained})" class LinearModel(Model): def __init__(self, name="Linear"): super().??? self.m = None self.b = None def train(self, data): # Basit lineer regresyon xs = [x for x, _ in data] ys = [y for _, y in data] n = len(data) x_mean = sum(xs) / n y_mean = sum(ys) / n # Egim: num = sum((x - x_mean) * (y - y_mean) for x, y in data) den = sum((x - x_mean) ** 2 for x in xs) self.m = num / den self.b = y_mean - self.m * x_mean self.trained = True def predict(self, x): if not self.trained: raise RuntimeError("Henuz egitilmedi") return self.m * x + self.b # Test: data = [(1, 2), (2, 4), (3, 6), (4, 8)] # y = 2x lin = LinearModel() lin.train(data) print(lin) # LinearModel(name='Linear', trained=True) print(lin.predict(5)) # ~10 (y = 2*5) ``` Bu egzersiz **scikit-learn** API'sinin mini hâlidir. Mosh'un öğrettiği OOP, gerçek ML kütüphanelerinin çekirdek API tasarımıdır. ::: {.callout-important title="🎓 Bu kursun final cümlesi"} Mosh'un Ders 1'de "Python öğrenmek = ML ekosisteminin bilet kasasına girmek" dediğimiz şey **artık gerçek**. Ders 2'de değişken, Ders 3'te input, Ders 4'te list/tuple, Ders 5'te fonksiyon, Ders 6'da if/else, Ders 7'de dict, Ders 8'de for-batch-in-dataloader, Ders 9'da preprocessing, Ders 10'da defansif kod, Ders 11'de pip install, ve Ders 12'de class — her satır seninle bugünden itibaren modern AI mühendisliği yolunda. **`class MyModel(nn.Module): def __init__(self): super().__init__(); self.layer = nn.Linear(...); def forward(self, x): return self.layer(x)`** artık sana yabancı değil — Mosh'un öğrettiği `class Student: def __init__(self, name): self.name = name; def graduate(self): return f"{self.name} mezun oldu"` ile **birebir** aynı yapı, sadece tensor ve gradient katılmış. Sonraki adım: `pip install torch transformers`, ve Karpathy'nin minGPT'sine git. Mosh'un sekiz saat boyunca öğrettiği her temel kavram, modern AI'nın yapı taşıdır — ve sen artık bunları biliyorsun. :::