AI & Machine Learning

CNN ile Derin Öğrenme: Convolutional Neural Network Rehberi

14 dk okuma19 Mart 2026
CNNConvolutional Neural NetworkDerin öğrenmeDeep learningCNN rehberiGörüntü sınıflandırmaImage classificationNeural networkCNN PythonCNN TensorFlowDerin öğrenme TürkçeYapay sinir ağları

Evrişimli Sinir Ağları (CNN - Convolutional Neural Networks), derin öğrenme alanının en güçlü mimarilerinden biridir. Görüntü sınıflandırma, nesne tespiti, yüz tanıma ve tıbbi görüntü analizi gibi görevlerde devrim niteliğinde sonuçlar üretmektedir. Bu yazıda CNN'in temel bileşenlerini, katman yapısını ve TensorFlow/Keras ile pratik bir model geliştirme sürecini inceleyeceğiz.

Derin Öğrenme Nedir?

Derin öğrenme, yapay sinir ağlarının birden fazla katmanla (derin katmanlar) oluşturulduğu bir makine öğrenmesi alt dalıdır. Geleneksel makine öğrenmesinde özellik çıkarımı (feature extraction) manuel yapılırken, derin öğrenme modelleri ham veriden otomatik olarak hiyerarşik özellikler öğrenir.

Neden CNN?

Tam bağlantılı (fully connected) ağlar, görüntü verileri için verimsizdir. 224x224x3 boyutunda bir RGB görüntü 150.528 girdi nöronuna sahiptir. CNN'ler bu sorunu şu şekilde çözer:

  • Parametre paylaşımı: Aynı filtre tüm görüntü üzerinde kaydırılır
  • Yerel bağlantılar: Her nöron yalnızca küçük bir bölgeye bakar
  • Mekansal hiyerarşi: Alt katmanlar kenarları, üst katmanlar karmaşık yapıları öğrenir

CNN Mimarisi

Evrişim Katmanı (Convolution Layer)

CNN'in kalbidir. Küçük filtreler (kernel) görüntü üzerinde kaydırılarak özellik haritaları (feature maps) üretir.

  • Filtre boyutu: Genellikle 3x3 veya 5x5
  • Stride: Filtrenin kaydırılma adımı
  • Padding: Çıktı boyutunu kontrol etmek için kenarlara eklenen sıfırlar
  • Aktivasyon: ReLU (Rectified Linear Unit) en yaygın kullanılan aktivasyondur

Havuzlama Katmanı (Pooling Layer)

Özellik haritalarının boyutlarını küçülterek hesaplama maliyetini azaltır ve aşırı öğrenmeyi önler.

  • Max Pooling: Pencere içindeki en büyük değeri alır (en yaygın)
  • Average Pooling: Pencere içindeki ortalamayı hesaplar
  • Global Average Pooling: Tüm haritayı tek bir değere indirger

Tam Bağlantılı Katman (Fully Connected Layer)

CNN'in son katmanlarında bulunur. Öğrenilen özellikleri sınıf tahminlerine dönüştürür.

TensorFlow/Keras ile CNN Modeli

Temel CNN Mimarisi

Aşağıda CIFAR-10 veri seti için bir CNN modeli örneği bulunmaktadır:

python
import tensorflow as tf
from tensorflow.keras import layers, models

# CNN modeli oluşturma
model = models.Sequential([
    # Birinci evrişim bloğu
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),

    # İkinci evrişim bloğu
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),

    # Üçüncü evrişim bloğu
    layers.Conv2D(128, (3, 3), activation='relu'),
    layers.BatchNormalization(),

    # Sınıflandırma katmanları
    layers.GlobalAveragePooling2D(),
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')
])

model.summary()

Veri Yükleme ve Ön İşleme

python
# CIFAR-10 veri setini yükleme
(X_egitim, y_egitim), (X_test, y_test) = tf.keras.datasets.cifar10.load_data()

# Piksel değerlerini [0, 1] aralığına normalize etme
X_egitim = X_egitim.astype('float32') / 255.0
X_test = X_test.astype('float32') / 255.0

# Veri artırma (Data Augmentation)
veri_artirma = tf.keras.Sequential([
    layers.RandomFlip("horizontal"),
    layers.RandomRotation(0.1),
    layers.RandomZoom(0.1),
    layers.RandomContrast(0.1),
])

# Artırılmış veri ile eğitim veri seti oluşturma
egitim_ds = tf.data.Dataset.from_tensor_slices((X_egitim, y_egitim))
egitim_ds = egitim_ds.shuffle(10000).batch(64).prefetch(tf.data.AUTOTUNE)

print(f"Eğitim seti: {X_egitim.shape}")
print(f"Test seti: {X_test.shape}")

Model Derleme ve Eğitim

python
# Model derleme
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Callback'ler
callbacks = [
    tf.keras.callbacks.EarlyStopping(
        monitor='val_loss', patience=5, restore_best_weights=True
    ),
    tf.keras.callbacks.ReduceLROnPlateau(
        monitor='val_loss', factor=0.5, patience=3
    )
]

# Eğitim
gecmis = model.fit(
    X_egitim, y_egitim,
    epochs=50,
    batch_size=64,
    validation_split=0.2,
    callbacks=callbacks
)

# Değerlendirme
test_kayip, test_dogruluk = model.evaluate(X_test, y_test)
print(f"Test Doğruluğu: {test_dogruluk:.2%}")

Dropout ve Regularizasyon

Derin sinir ağlarında aşırı öğrenme (overfitting) en yaygın sorunlardan biridir. Model eğitim verisini ezberler ve yeni veriye genelleyemez. Bu sorunu çözmek için çeşitli regularizasyon teknikleri kullanılır.

Dropout, eğitim sırasında rastgele nöronları devre dışı bırakarak modelin belirli nöronlara aşırı bağımlı olmasını engeller. Her eğitim adımında farklı bir alt ağ eğitilmiş olur, bu da bir tür topluluk (ensemble) etkisi yaratır. Tam bağlantılı katmanlarda genellikle %30-50 oranında, evrişim katmanlarından sonra ise %10-25 oranında dropout uygulanır.

L2 Regularizasyon (Weight Decay) ise ağırlıkların büyük değerler almasını cezalandırarak modelin daha basit kalmasını sağlar. Kernel regularizer parametresi ile her katmana eklenebilir:

python
from tensorflow.keras import regularizers

# Regularizasyon ile geliştirilmiş CNN modeli
model_reg = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3),
                  kernel_regularizer=regularizers.l2(1e-4)),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.15),

    layers.Conv2D(64, (3, 3), activation='relu',
                  kernel_regularizer=regularizers.l2(1e-4)),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.2),

    layers.Conv2D(128, (3, 3), activation='relu',
                  kernel_regularizer=regularizers.l2(1e-4)),
    layers.BatchNormalization(),

    layers.GlobalAveragePooling2D(),
    layers.Dense(256, activation='relu',
                 kernel_regularizer=regularizers.l2(1e-4)),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')
])

Regularizasyon tekniklerini birlikte kullanmak genellikle en iyi sonucu verir. Batch normalization da dolaylı bir regularizasyon etkisi sağlar, çünkü mini-batch istatistikleri eğitim sırasında gürültü ekler.

Öğrenme Hızı Planlaması (Learning Rate Scheduling)

Sabit bir öğrenme hızı kullanmak çoğu zaman optimal değildir. Eğitimin başında yüksek bir öğrenme hızı ile geniş parametre alanı keşfedilir, ardından öğrenme hızı azaltılarak daha ince ayar yapılır. Bu strateji, modelin hem hızlı yakınsamasını hem de daha iyi bir optimuma ulaşmasını sağlar.

python
# Cosine decay ile öğrenme hızı planlaması
ilk_ogrenme_hizi = 0.001
bozunma_adimlari = 1000

lr_planlama = tf.keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=ilk_ogrenme_hizi,
    decay_steps=bozunma_adimlari,
    alpha=1e-6  # Minimum öğrenme hızı
)

# Warm-up ile cosine decay (önerilen yaklaşım)
class WarmupCosineDecay(tf.keras.optimizers.schedules.LearningRateSchedule):
    def __init__(self, warmup_steps, total_steps, peak_lr):
        super().__init__()
        self.warmup_steps = warmup_steps
        self.total_steps = total_steps
        self.peak_lr = peak_lr

    def __call__(self, step):
        warmup = self.peak_lr * (step / self.warmup_steps)
        cosine = 0.5 * self.peak_lr * (1 + tf.cos(
            np.pi * (step - self.warmup_steps) / (self.total_steps - self.warmup_steps)
        ))
        return tf.where(step < self.warmup_steps, warmup, cosine)

optimizer = tf.keras.optimizers.Adam(learning_rate=lr_planlama)

Model Değerlendirme ve Confusion Matrix

Modelin performansını derinlemesine anlamak için confusion matrix ve sınıf bazında metrikler kullanmak gerekir. Confusion matrix, her sınıf için doğru ve yanlış tahminlerin dağılımını gösterir ve modelin hangi sınıflarda zorlandığını ortaya koyar.

python
from sklearn.metrics import confusion_matrix, classification_report
import seaborn as sns
import matplotlib.pyplot as plt

# Test seti üzerinde tahmin
y_tahmin = model.predict(X_test)
y_tahmin_siniflar = np.argmax(y_tahmin, axis=1)
y_gercek = y_test.flatten()

# CIFAR-10 sınıf isimleri
sinif_isimleri = ['Uçak', 'Otomobil', 'Kuş', 'Kedi', 'Geyik',
                  'Köpek', 'Kurbağa', 'At', 'Gemi', 'Kamyon']

# Confusion Matrix
cm = confusion_matrix(y_gercek, y_tahmin_siniflar)

plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=sinif_isimleri, yticklabels=sinif_isimleri)
plt.title('Confusion Matrix')
plt.xlabel('Tahmin Edilen')
plt.ylabel('Gerçek')
plt.tight_layout()
plt.savefig('confusion_matrix.png', dpi=150)
plt.show()

# Detaylı sınıflandırma raporu
print(classification_report(y_gercek, y_tahmin_siniflar, target_names=sinif_isimleri))

Bu analiz sayesinde modelin hangi sınıfları karıştırdığını görebilirsiniz. Örneğin kedi ve köpek sınıfları arasındaki karışıklık beklenen bir durumdur, çünkü bu sınıflar görsel olarak birbirine benzer.

Transfer Öğrenme

Sıfırdan model eğitmek yerine, önceden eğitilmiş modelleri kullanarak daha az veriyle yüksek performans elde edebilirsiniz. Transfer öğrenme, büyük veri setleri (ImageNet gibi) üzerinde eğitilmiş bir modelin öğrendiği genel görsel özellikleri kendi probleminize aktarmanıza olanak tanır.

Bu yaklaşım özellikle sınırlı veri ile çalışırken son derece etkilidir. ImageNet üzerinde eğitilmiş bir modelin alt katmanları kenarlar, dokular ve basit şekiller gibi evrensel özellikleri zaten öğrenmiştir. Bu katmanları dondurarak yalnızca üst sınıflandırma katmanlarını kendi veri setinize göre eğitebilirsiniz.

python
# Transfer öğrenme ile model oluşturma
base_model = tf.keras.applications.ResNet50V2(
    include_top=False,
    weights='imagenet',
    input_shape=(224, 224, 3)
)
base_model.trainable = False  # Tüm katmanları dondur

# Kendi sınıflandırma katmanlarınızı ekleyin
model_tl = models.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(),
    layers.BatchNormalization(),
    layers.Dense(256, activation='relu'),
    layers.Dropout(0.4),
    layers.Dense(10, activation='softmax')
])

model_tl.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Fine-tuning: Üst katmanları açarak ince ayar
base_model.trainable = True
for layer in base_model.layers[:-20]:
    layer.trainable = False

model_tl.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

Özellik Haritalarını Görselleştirme

CNN'in hangi özellikleri öğrendiğini anlamak için ara katmanların çıktılarını görselleştirebilirsiniz. Bu teknik hem hata ayıklama hem de modelin karar sürecini açıklama açısından değerlidir. Alt katmanlar kenarlar ve renkler gibi düşük seviyeli özellikleri, üst katmanlar ise nesne parçaları ve karmaşık yapılar gibi yüksek seviyeli özellikleri öğrenir.

python
# Ara katman çıktılarını görselleştirme
from tensorflow.keras.models import Model

# İlk evrişim katmanının çıktısını al
ara_model = Model(
    inputs=model.input,
    outputs=model.layers[0].output  # İlk Conv2D katmanı
)

# Tek bir görüntü ile tahmin
ornek_goruntu = X_test[0:1]
ozellik_haritalari = ara_model.predict(ornek_goruntu)

# Özellik haritalarını görselleştir
fig, axes = plt.subplots(4, 8, figsize=(16, 8))
for i, ax in enumerate(axes.flat):
    if i < ozellik_haritalari.shape[-1]:
        ax.imshow(ozellik_haritalari[0, :, :, i], cmap='viridis')
    ax.axis('off')
plt.suptitle('İlk Evrişim Katmanı Özellik Haritaları')
plt.tight_layout()
plt.savefig('ozellik_haritalari.png', dpi=150)
plt.show()

Popüler CNN Mimarileri

Yıllar içinde geliştirilmiş önemli CNN mimarileri:

  • LeNet-5 (1998): El yazısı rakam tanıma için tasarlandı
  • AlexNet (2012): ImageNet yarışmasını kazanarak derin öğrenme devrimini başlattı
  • VGGNet (2014): 3x3 filtrelerle derin ağların gücünü gösterdi
  • ResNet (2015): Skip connection ile 152 katmana kadar eğitimi mümkün kıldı
  • EfficientNet (2019): Model ölçekleme stratejisi ile verimli mimari

Optimizasyon İpuçları

  1. Batch Normalization: Her katmandan sonra kullanarak eğitimi stabilize edin
  2. Dropout: Tam bağlantılı katmanlarda %30-50 oranında uygulayın
  3. Data Augmentation: Veri setinizi yapay olarak büyütün
  4. Learning Rate Scheduling: Eğitim ilerledikçe öğrenme hızını azaltın
  5. Mixed Precision Training: FP16 ile eğitim hızını artırın

Özet

CNN'ler, görüntü sınıflandırma ve bilgisayarla görme alanının temel yapı taşıdır. Evrişim, havuzlama ve tam bağlantılı katmanların kombinasyonu ile ham piksel verilerinden anlamlı özellikler çıkarır. Dropout ve L2 regularizasyon ile aşırı öğrenmeyi kontrol altında tutarken, cosine decay gibi öğrenme hızı planlaması stratejileri ile eğitim sürecini optimize edebilirsiniz. Confusion matrix analizi modelin hangi sınıflarda zorlandığını ortaya koyar, transfer öğrenme ise sınırlı veriyle bile yüksek başarı sağlar. Özellik haritalarını görselleştirmek, modelin karar mekanizmasını anlamak için güçlü bir araçtır. TensorFlow/Keras ile bu mimarileri birkaç satır kodla oluşturabilir ve modern derin öğrenme projelerinde başarıyla uygulayabilirsiniz.

İlgili Makaleler

Makine Öğrenmesi Nedir? Python ile Temel Kavramlar ve İlk Model

Makine öğrenmesine giriş. Supervised, unsupervised ve reinforcement learning kavramları. Python, NumPy ve Scikit-learn ile ilk model.

TensorFlow ile Model Eğitimi: Veri Hazırlama, Eğitim ve Değerlendirme

TensorFlow ve Keras ile model eğitimi rehberi. Veri ön işleme, model tasarımı, eğitim döngüsü, hiperparametre ayarı ve model değerlendirme.

Flutter Projeniz mi Var?

iOS, Android ve web için yüksek performanslı Flutter uygulamaları geliştiriyorum.

İletişime Geç