Derin Öğrenmenin Anatomisi (Teoriden Kodlamaya Uçtan Uca Rehber)

🧠 Derin Öğrenmenin Anatomisi: Sıfırdan Matematiksel Mantık ve Modern Mimariler (ANN, CNN, RNN/LSTM)

📌 Giriş: Yapay Zekâ Mühendisliğinde "Black Box" Yaklaşımının Tehlikeleri

Modern yapay zekâ ekosisteminde derin öğrenme modelleri geliştirmek hiç olmadığı kadar kolaylaşmıştır. Keras, PyTorch ve TensorFlow gibi yüksek seviyeli kütüphaneler sayesinde birkaç satır kodla karmaşık bir sinir ağı eğitmek mümkündür.

# Hazır kütüphanelerle model eğitimi

model.compile(
    optimizer='adam',
    loss='binary_crossentropy'
)

model.fit(
    X_train,
    y_train,
    epochs=10
)

Ancak bir Yapay Zekâ Mühendisi açısından yalnızca model.fit() yazıp süreci tamamen soyut kütüphanelere bırakmak teknik açıdan yetersiz olabilir. Bu yaklaşım sektörde çoğu zaman "Black Box" (Kara Kutu) yaklaşımı olarak ifade edilir.

❓ Neden sadece hazır fonksiyon çağırmak yeterli değildir?

🗺️ Yol Haritası: Teoriden Mimarilere Uçtan Uca Yolculuk

Bu rehber boyunca soyut kabul edilen algoritmaları matris seviyesinde inceleyeceğiz.

1. Veri Ön İşleme: Görselleri matrisel vektörlere dönüştürme, normalizasyon ve One-Hot Encoding.
2. Lojistik Regresyon: Tek nöronlu temel yapay sinir ağını NumPy ile sıfırdan kodlama.
3. Yapay Sinir Ağları (ANN): Gizli katmanlar, Tanh/Sigmoid ve ağırlık ilklendirme.
4. Evrişimli Sinir Ağları (CNN): Kernel, Padding, Max Pooling ve Dropout.
5. RNN & LSTM: Zamansal bağımlılıklar, dahili bellek ve kapı mekanizmaları.

📘 Bölüm 1: Veri Ön İşleme ve Tensör Manipülasyonu

Derin öğrenme modellerinin kalitesi, doğrudan beslendikleri verinin kalitesine ve matematiksel temsil biçimine bağlıdır. İster basit bir ANN ister karmaşık bir CNN kullanalım, modeller görüntüleri doğrudan anlayamaz. Onların işleyebildiği temel yapı çok boyutlu diziler, yani tensörlerdir.

1.1 Verinin Doğasını Anlamak: Görseller ve Piksel Matrisleri

Derin öğrenmede görüntüler sayısal değerlerden oluşan matrislerdir.

🤟 Sign Language Digit Dataset

0'dan 9'a kadar el işaretlerini içeren veri setindeki görüntüler 64 × 64 çözünürlüğündedir ve grayscale yapıdadır.

Siyah-beyaz görüntü yalnızca bir kanala sahiptir:

🔢 MNIST / Digit Recognizer Dataset

MNIST görüntüleri 28 × 28 çözünürlüğündedir.

Piksel değerleri genellikle 0–255 aralığında bulunan uint8 değerleridir.

RGB renkli görüntülerde ise üç kanal bulunur:

1.2 Normalizasyon (Normalization) ve Ölçekleme

Ham piksel değerlerini 0–255 aralığında doğrudan sinir ağına vermek, eğitim sürecinin stabilitesini olumsuz etkileyebilir. Bu nedenle değerleri genellikle [0, 1] aralığına ölçekleriz.

⚡ Normalizasyonun İki Kritik Faydası

🐍 Python ile Piksel Normalizasyonu

# Piksel değerlerini 0-255 aralığından
# 0-1 aralığına çekme

X_train_normalized = X_train / 255.0
X_test_normalized = X_test / 255.0

print(
    "Max Piksel Değeri:",
    np.max(X_train_normalized)
)

# Çıktı: 1.0

print(
    "Min Piksel Değeri:",
    np.min(X_train_normalized)
)

# Çıktı: 0.0

1.3 Matris Dönüştürme (Reshaping) ve Flattening

🔹 ANN ve Lojistik Regresyon

64 × 64 görüntüyü düzleştirirsek:

Dolayısıyla:

Buradaki N örnek sayısını ifade eder.

🔹 CNN İçin

CNN modellerinde kanal boyutunun açıkça belirtilmesi gerekir.

28 × 28 grayscale görüntü için:

🐍 CNN İçin Kanal Ekleme

# CNN için kanal boyutu ekleme

X_train_cnn = X_train_normalized.reshape(
    -1, 28, 28, 1
)

print(
    "CNN Girdi Boyutu:",
    X_train_cnn.shape
)

# Örnek:
# (37800, 28, 28, 1)

1.4 Etiket Dönüşümü: One-Hot Encoding

Sınıflandırma problemlerinde etiketler 0, 1, 2, ..., 9 gibi tam sayılar şeklinde tutulabilir. Ancak sınıfların büyüklük/küçüklük ilişkisine sahip olmadığı çoklu sınıflandırma problemlerinde bu değerleri kategorik vektörlere dönüştürmek daha uygundur.

One-Hot Örneği

🐍 Python ile One-Hot Encoding

# Etiketleri kategorik vektörlere dönüştürme

Y_train_encoded = to_categorical(
    Y_train,
    num_classes=10
)

Y_test_encoded = to_categorical(
    Y_test,
    num_classes=10
)

print(
    "Ham Etiket:",
    Y_train[0]
)

print(
    "One-Hot Encoded Etiket:",
    Y_train_encoded[0]
)

📐 Bölüm 2: Derin Öğrenmenin Yapı Taşı – Lojistik Regresyon ve Sıfırdan Kodlama

Lojistik Regresyon yalnızca klasik bir Makine Öğrenmesi algoritması olarak düşünülmemelidir. Teknik olarak gizli katmanı bulunmayan, tek nöronlu en basit sinir ağı mimarisi olarak ele alınabilir.

2.1 Hesaplama Grafiği (Computation Graph)

64 × 64 çözünürlüğündeki görüntü:

N adet örnek için:

Ağırlık matrisi:

Bias ise skaler bir değerdir.

2.2 İleri Yayılım (Forward Propagation)

1. Lineer Bireşim

2. Sigmoid Aktivasyonu

• Z → ∞ ise A → 1
• Z → −∞ ise A → 0
• Z = 0 ise A = 0.5

3. Binary Cross-Entropy Loss

Cost Function

2.3 Geri Yayılım ve Türevler

⚙️ Gradient Descent

2.4 NumPy ile From Scratch Lojistik Regresyon

1. Sigmoid

def sigmoid(z):

    return 1 / (1 + np.exp(-z))

2. Parametre İlklendirme

def initialize_weights_and_bias(dimension):

    w = np.full(
        (dimension, 1),
        0.01
    )

    b = 0.0

    return w, b

3. Forward & Backward Propagation

def forward_backward_propagation(
        w,
        b,
        x_train,
        y_train
    ):

    m = x_train.shape[1]


    # Forward Propagation

    z = np.dot(
        w.T,
        x_train
    ) + b

    a = sigmoid(z)


    loss = -(
        y_train * np.log(a)
        +
        (1 - y_train)
        * np.log(1 - a)
    )


    cost = np.sum(loss) / m


    # Backward Propagation

    derivative_weight = (
        np.dot(
            x_train,
            (a - y_train).T
        ) / m
    )


    derivative_bias = (
        np.sum(a - y_train)
        / m
    )


    gradients = {

        "derivative_weight":
            derivative_weight,

        "derivative_bias":
            derivative_bias

    }


    return cost, gradients

4. Gradient Descent

def update_parameters(
        w,
        b,
        x_train,
        y_train,
        learning_rate,
        num_iterations
    ):

    cost_list = []


    for i in range(num_iterations):

        cost, gradients = (
            forward_backward_propagation(
                w,
                b,
                x_train,
                y_train
            )
        )


        # Ağırlık Güncellemesi

        w = (
            w
            -
            learning_rate
            * gradients["derivative_weight"]
        )


        b = (
            b
            -
            learning_rate
            * gradients["derivative_bias"]
        )


        if i % 10 == 0:

            cost_list.append(cost)


    parameters = {

        "weight": w,

        "bias": b

    }


    return parameters, gradients, cost_list

5. Tahmin

def predict(w, b, x_test):

    z = sigmoid(
        np.dot(w.T, x_test) + b
    )


    y_prediction = np.zeros(
        (1, x_test.shape[1])
    )


    for i in range(z.shape[1]):

        if z[0, i] <= 0.5:

            y_prediction[0, i] = 0

        else:

            y_prediction[0, i] = 1


    return y_prediction

2.5 Scikit-Learn ile Karşılaştırma

from sklearn.linear_model import LogisticRegression


logreg = LogisticRegression(
    max_iter=150,
    random_state=42
)


logreg.fit(
    x_train.T,
    y_train.T.ravel()
)


test_accuracy = logreg.score(
    x_test.T,
    y_test.T.ravel()
)


print(
    "Scikit-Learn Test Başarımı: {:.2f}%"
    .format(test_accuracy * 100)
)

🧠 Bölüm 3: Yapay Sinir Ağları (ANN) ve Derinleşen Mimariler

Lojistik Regresyon ile tek nöronlu bir ağ kurmayı öğrendik. Ancak gerçek hayattaki karmaşık ve doğrusal olmayan problemlerin tek nöronla çözülmesi mümkün değildir. Bu noktada Artificial Neural Networks (ANN) devreye girer.

3.1 Katman (Layer) ve Düğüm (Node) Yapısı

3.2 "Deep" Ne Anlama Gelir?

Deep Learning'deki derinlik, ağ içerisinde bulunan Hidden Layer sayısıyla doğrudan ilişkilidir.

• İlk katmanlar: Kenarlar ve basit geometrik yapılar.
• Orta katmanlar: Daireler, kıvrımlar ve basit şekiller.
• Derin katmanlar: Göz, yüz, parmak veya karmaşık nesne parçaları.

3.3 Tanh vs. Sigmoid

🔹 Neden Tanh?

Tanh fonksiyonu zero-centered bir çıktı üretir. Bu durum gizli katmanlarda optimizasyonun daha dengeli ilerlemesine yardımcı olabilir.

3.4 Simetriyi Kırma (Symmetry Breaking)

Çok katmanlı ağlarda tüm ağırlıkları sıfır başlatmak Symmetry Problem oluşturur. Aynı katmandaki nöronlar aynı hesaplamayı yapar, aynı gradyanları alır ve aynı şeyi öğrenir. Sonuç olarak 100 nöronumuz olsa bile ağ pratikte tek bir nöron gibi davranabilir.

Çözüm: Random Initialization

Ağırlıkların küçük seçilmesinin nedeni, çok büyük ağırlıkların Sigmoid veya Tanh fonksiyonlarını doygunluk bölgelerine götürerek gradyanları küçültmesidir.

3.5 NumPy ile From Scratch 2-Layer ANN

1. Parametrelerin İlklendirilmesi

def initialize_parameters_ann(
        n_x,
        n_h,
        n_y
    ):

    W1 = (
        np.random.randn(n_h, n_x)
        * 0.01
    )

    b1 = np.zeros(
        (n_h, 1)
    )


    W2 = (
        np.random.randn(n_y, n_h)
        * 0.01
    )

    b2 = np.zeros(
        (n_y, 1)
    )


    parameters = {

        "W1": W1,
        "b1": b1,

        "W2": W2,
        "b2": b2

    }


    return parameters

2. Forward Propagation

def forward_propagation_ann(
        X,
        parameters
    ):

    W1 = parameters["W1"]
    b1 = parameters["b1"]

    W2 = parameters["W2"]
    b2 = parameters["b2"]


    # Katman 1 - Hidden Layer

    Z1 = np.dot(W1, X) + b1

    A1 = np.tanh(Z1)


    # Katman 2 - Output Layer

    Z2 = np.dot(W2, A1) + b2

    A2 = (
        1
        /
        (1 + np.exp(-Z2))
    )


    cache = {

        "Z1": Z1,
        "A1": A1,

        "Z2": Z2,
        "A2": A2

    }


    return A2, cache

3. Backward Propagation

def backward_propagation_ann(
        parameters,
        cache,
        X,
        Y
    ):

    m = X.shape[1]


    W2 = parameters["W2"]

    A1 = cache["A1"]

    A2 = cache["A2"]


    # Çıktı Katmanı Gradyanları

    dZ2 = A2 - Y

    dW2 = (
        np.dot(dZ2, A1.T)
        / m
    )

    db2 = (
        np.sum(
            dZ2,
            axis=1,
            keepdims=True
        )
        / m
    )


    # Gizli Katman Gradyanları

    dZ1 = (
        np.dot(W2.T, dZ2)
        *
        (1 - np.power(A1, 2))
    )


    dW1 = (
        np.dot(dZ1, X.T)
        / m
    )


    db1 = (
        np.sum(
            dZ1,
            axis=1,
            keepdims=True
        )
        / m
    )


    grads = {

        "dW1": dW1,
        "db1": db1,

        "dW2": dW2,
        "db2": db2

    }


    return grads

3.6 Keras ile L-Layer ANN

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense


# Model

classifier = Sequential()


# 1. Gizli Katman

classifier.add(
    Dense(
        units=8,
        kernel_initializer='uniform',
        activation='relu',
        input_dim=4096
    )
)


# 2. Gizli Katman

classifier.add(
    Dense(
        units=4,
        kernel_initializer='uniform',
        activation='relu'
    )
)


# Çıktı Katmanı

classifier.add(
    Dense(
        units=1,
        kernel_initializer='uniform',
        activation='sigmoid'
    )
)


# Compile

classifier.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)


# Eğitim

classifier.fit(
    X_train,
    Y_train,
    batch_size=32,
    epochs=100
)

🖼️ Bölüm 4: Görsel İşlemenin Gücü – Evrişimli Sinir Ağları (CNN)

ANN modellerinde görüntüleri düzleştirerek tek boyutlu vektörlere dönüştürüyorduk. Ancak bu işlem önemli bir bilgiyi kaybettirir: Mekânsal / Uzamsal İlişkiler.

Bir görüntüde gözün, kulağın veya bir kenarın anlamı yalnızca piksel değerinden değil, çevresindeki piksellerle olan komşuluğundan da gelir. CNN'ler bu uzamsal yapıyı koruyarak özellik çıkarımı yapar.

4.1 Katman Katman CNN Mimarisi

1. Convolution Katmanı

Evrişim katmanının amacı görüntü üzerindeki:

• Kenarları
• Köşeleri
• Dokuları
• Karmaşık desenleri

tespit etmektir. Filtre görüntü üzerinde gezdirilir ve element-wise çarpımların toplamı alınarak Feature Map oluşturulur.

2. Same Padding ve Stride

3. Max Pooling

Max Pooling, Feature Map boyutunu küçültmek ve en baskın özellikleri korumak için kullanılır.

• Boyutları küçültür.
• Hesaplama maliyetini azaltır.
• Önemli özellikleri öne çıkarır.
• Translation Invariance sağlar.

4. Dropout

Eğitim sırasında belirli orandaki nöronları rastgele devre dışı bırakarak nöronların birbirine aşırı bağımlı hale gelmesini engeller. Bu sayede Overfitting riski azaltılır.

5. Flattening ve Fully Connected Layer

Convolution ve Pooling katmanlarından gelen 2D/3D Feature Map'ler Flatten katmanı ile tek boyutlu vektöre dönüştürülür. Bu vektör Dense katmanlarına aktarılır.

Softmax

10 sınıflı çoklu sınıflandırma problemlerinde çıktı katmanında Softmax kullanılabilir.

4.2 Keras ile CNN İmplementasyonu

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import (
    Conv2D,
    MaxPooling2D,
    Dropout,
    Flatten,
    Dense
)


# Model

model = Sequential()


# -------------------------------------------------
# Blok 1
# Conv2D + MaxPool + Dropout
# -------------------------------------------------

model.add(
    Conv2D(
        filters=8,
        kernel_size=(5, 5),
        padding='same',
        activation='relu',
        input_shape=(28, 28, 1)
    )
)


model.add(
    MaxPooling2D(
        pool_size=(2, 2)
    )
)


model.add(
    Dropout(0.25)
)


# -------------------------------------------------
# Blok 2
# -------------------------------------------------

model.add(
    Conv2D(
        filters=16,
        kernel_size=(3, 3),
        padding='same',
        activation='relu'
    )
)


model.add(
    MaxPooling2D(
        pool_size=(2, 2),
        strides=(2, 2)
    )
)


model.add(
    Dropout(0.25)
)


# -------------------------------------------------
# Classification
# -------------------------------------------------

model.add(
    Flatten()
)


model.add(
    Dense(
        256,
        activation='relu'
    )
)


model.add(
    Dropout(0.5)
)


model.add(
    Dense(
        10,
        activation='softmax'
    )
)


# -------------------------------------------------
# Optimizer
# -------------------------------------------------

optimizer = Adam(
    learning_rate=0.001,
    beta_1=0.9,
    beta_2=0.999
)


model.compile(
    optimizer=optimizer,
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

4.3 Veri Artırma (Data Augmentation)

Veri setimiz küçük olduğunda mevcut görüntüler üzerinde küçük sentetik değişiklikler yaparak eğitim verisini çeşitlendirebiliriz.

• Rotation: Görüntüyü belirli açılarda döndürme.
• Zoom: Görüntüyü yakınlaştırma veya uzaklaştırma.
• Shift: Görüntüyü yatay veya dikey olarak kaydırma.

🐍 Keras Data Augmentation

from tensorflow.keras.preprocessing.image import (
    ImageDataGenerator
)


datagen = ImageDataGenerator(

    rotation_range=10,

    zoom_range=0.1,

    width_shift_range=0.1,

    height_shift_range=0.1
)


datagen.fit(X_train)


# Model Eğitimi

history = model.fit(

    datagen.flow(
        X_train,
        Y_train,
        batch_size=250
    ),

    epochs=30,

    validation_data=(
        X_val,
        Y_val
    )
)

⏱️ Bölüm 5: Zamansal Bağımlılıklar – Yinelemeli Sinir Ağları (RNN) ve LSTM

ANN ve CNN modellerinde veriler çoğu zaman birbirinden bağımsız örnekler olarak ele alınabilir. Ancak bazı veri türlerinde sıralama çok önemlidir.

• Borsa: Geçmiş fiyatlar gelecekteki fiyatları etkileyebilir.
• NLP: Bir kelimenin anlamı önceki kelimelere bağlıdır.
• Ses: Ses dalgaları zamana yayılmış dizilerdir.

Standart bir ANN geçmişte ne olduğunu hatırlayamaz. Bu nedenle zaman bilgisine sahip Recurrent Neural Networks (RNN) kullanılır.

5.1 RNN Mimarisi ve Geçici Bellek

RNN'in temel farkı, mevcut çıktının yalnızca mevcut girdiye değil, önceki zaman adımındaki Hidden State değerine de bağlı olmasıdır.

• xₜ: Mevcut zaman adımındaki girdi.
• hₜ₋₁: Önceki zaman adımından gelen bellek.
• hₜ: Güncellenmiş gizli durum.

⚠️ Vanishing Gradient Problemi

Standart RNN'ler uzun dizilerde geçmiş bilgileri öğrenmekte zorlanabilir. Backpropagation Through Time sırasında gradyanlar birçok küçük değerle çarpıldığında giderek sıfıra yaklaşabilir. Bu durum Vanishing Gradient olarak adlandırılır.

5.2 LSTM (Long Short-Term Memory)

LSTM, standart RNN'lerin uzun süreli bağımlılıkları öğrenme problemine çözüm getirmek amacıyla geliştirilmiştir. LSTM içerisinde bilginin daha uzun süre taşınmasını sağlayan bir Cell State bulunur. Bu bilgi akışı kapılar tarafından kontrol edilir.

1. Forget Gate

Geçmiş bilginin ne kadarının unutulacağına karar verir.

2. Input Gate

Yeni bilginin hafızaya ne kadar ekleneceğini belirler.

3. Cell State Update

Eski hafıza ve yeni bilgi birleştirilerek güncellenir.

4. Output Gate

5.3 Keras ile Zaman Serisi / Borsa Tahmini

1. Time Step = 50 Veri Yapısı

# Zaman pencereli veri

X_train = []
Y_train = []


# Geçmiş 50 gün
# 51. günü hedefle

for i in range(
        50,
        len(train_scaled)
    ):

    X_train.append(
        train_scaled[
            i-50:i,
            0
        ]
    )

    Y_train.append(
        train_scaled[
            i,
            0
        ]
    )


X_train = np.array(
    X_train
)

Y_train = np.array(
    Y_train
)


# 3D Reshape
# (Samples, Time Steps, Features)

X_train = np.reshape(
    X_train,
    (
        X_train.shape[0],
        X_train.shape[1],
        1
    )
)

2. LSTM Modeli

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import (
    LSTM,
    Dropout,
    Dense
)


regressor = Sequential()


# Katman 1

regressor.add(

    LSTM(
        units=50,
        return_sequences=True,
        input_shape=(
            X_train.shape[1],
            1
        )
    )

)

regressor.add(
    Dropout(0.2)
)


# Katman 2

regressor.add(

    LSTM(
        units=50,
        return_sequences=True
    )

)

regressor.add(
    Dropout(0.2)
)


# Katman 3

regressor.add(

    LSTM(
        units=50,
        return_sequences=False
    )

)

regressor.add(
    Dropout(0.2)
)


# Çıktı Katmanı

regressor.add(

    Dense(
        units=1
    )

)


# Compile

regressor.compile(

    optimizer='adam',

    loss='mean_squared_error'

)


# Eğitim

regressor.fit(

    X_train,

    Y_train,

    epochs=100,

    batch_size=32

)

🛠️ Bölüm 6: Bir AI Mühendisinin Alet Çantası ve Hiperparametre Yönetimi

Bir model mimarisi oluşturmak derin öğrenme sürecinin sonu değildir. Asıl mühendislik süreci modelin hiperparametrelerinin doğru şekilde ayarlanması ile başlar.

Parametreler (Weights ve Bias), eğitim sırasında öğrenilen değerlerdir. Hiperparametreler ise eğitim başlamadan önce mühendis tarafından belirlenen değerlerdir.

6.1 Kritik Hiperparametreler

1. Learning Rate (α)

2. Epoch ve Batch Size

Epoch: Eğitim veri setinin tamamının ağ üzerinden bir kez geçirilmesidir.

Batch Size: Bir eğitim adımında modele kaç örneğin birlikte verileceğini belirler.

Küçük batch değerleri daha az bellek kullanabilirken, büyük batch değerleri donanımın paralel işlem kapasitesinden daha fazla yararlanabilir.

3. Hidden Layer ve Nöron Sayısı

6.2 İnteraktif Araçlar ve Görselleştirme

Hiperparametrelerin karar sınırlarını nasıl değiştirdiğini anlamak için görselleştirme oldukça önemlidir.

6.3 Performans Metrikleri ve Model Değerlendirme

Bir modeli yalnızca nihai Accuracy değeriyle değerlendirmek yanıltıcı olabilir. Modelin eğitim sürecini ve hangi sınıflarda hata yaptığını da incelemek gerekir.

1. Epoch / Loss - Accuracy Grafikleri

Hem Train Loss hem de Validation Loss eğrileri takip edilmelidir.

2. Confusion Matrix (Karmaşıklık Matrisi)

Confusion Matrix, modelin hangi sınıfları birbirleriyle karıştırdığını açıkça gösterir. Örneğin model belirli iki rakamı sürekli karıştırıyorsa, bu sınıflara ait veri sayısı veya Data Augmentation stratejisi yeniden değerlendirilmelidir.

🐍 Confusion Matrix ile Model Değerlendirme

from sklearn.metrics import (
    confusion_matrix
)

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns


# Tahminler

Y_pred = model.predict(
    X_val
)


Y_pred_classes = np.argmax(
    Y_pred,
    axis=1
)


Y_true = np.argmax(
    Y_val,
    axis=1
)


# Confusion Matrix

cm = confusion_matrix(
    Y_true,
    Y_pred_classes
)


# Görselleştirme

plt.figure(
    figsize=(8, 8)
)


sns.heatmap(
    cm,
    annot=True,
    fmt='d',
    cmap='Blues'
)


plt.xlabel(
    'Tahmin Edilen Sınıf'
)


plt.ylabel(
    'Gerçek Sınıf'
)


plt.title(
    'Confusion Matrix'
)


plt.show()

🎯 Sonuç ve Değerlendirme

Derin Öğrenme yalnızca yüksek seviyeli kütüphanelerle model mimarileri tanımlayıp model.fit() çalıştırmaktan ibaret değildir. Bu rehber boyunca teorik altyapıyı pratik kodlama ile birleştirerek derin öğrenmenin temel yapı taşlarını matematiksel seviyede ele aldık.

🔗 Proje Kodları ve Kaynaklar

Bu rehberde ele alınan algoritmaların, sıfırdan NumPy uygulamalarının, Keras/PyTorch modellerinin ve Jupyter Notebook çalışmalarının tamamını GitHub projesi üzerinden inceleyebilirsin.