Evrişimsel Sinir Ağları (Convolutional Neural Networks – CNN), özellikle görüntü işleme ve sınıflandırma görevlerinde devrim yaratan derin öğrenme mimarilerindendir. Bu makalede, TensorFlow kullanarak adım adım bir CNN modeli oluşturmayı ve eğitmeyi öğreneceğiz.
İçindekiler
- Evrişimsel Sinir Ağları Nedir?
- Gerekli Kütüphanelerin Kurulumu
- Veri Setinin Hazırlanması
- CNN Modelinin Oluşturulması
- Modelin Eğitilmesi
- Modelin Değerlendirilmesi
- Tahminlerin Görselleştirilmesi
- İleri Seviye Teknikler
Evrişimsel Sinir Ağları Nedir?
Evrişimsel Sinir Ağları, insan görsel korteksinden ilham alan ve özellikle görüntü tanıma problemlerinde etkili olan özel bir yapay sinir ağı türüdür. Geleneksel sinir ağlarından farklı olarak CNN’ler, görüntülerdeki uzamsal ilişkileri koruyabilen evrişim katmanlarını kullanır.
CNN’lerin temel bileşenleri:
- Evrişim (Convolution) Katmanları: Görüntüdeki özellikleri (kenarlar, dokular vb.) tespit eden filtreler kullanır.
- Havuzlama (Pooling) Katmanları: Uzamsal boyutları azaltarak hesaplama yükünü hafifletir.
- Tamamen Bağlı (Fully Connected) Katmanlar: Önceki katmanlardan çıkarılan özellikleri kullanarak sınıflandırma yapar.
Gerekli Kütüphanelerin Kurulumu
İlk olarak, gerekli kütüphaneleri içe aktaralım:
import tensorflow as tf
from tensorflow.keras import datasets, layers, models
import matplotlib.pyplot as plt
import numpy as np
TensorFlow 2.x sürümünde olduğumuzdan emin olalım:
print("TensorFlow sürümü:", tf.__version__)
Veri Setinin Hazırlanması
Bu eğitimde, CIFAR-10 veri setini kullanacağız. Bu veri seti, 10 farklı sınıfa ait 60.000 adet 32×32 piksel renkli görüntü içerir.
# CIFAR-10 veri setini yükleme
(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()
# Piksel değerlerini 0-1 arasına normalizasyonu
train_images = train_images / 255.0
test_images = test_images / 255.0
# Sınıf isimlerini tanımlama
class_names = ['uçak', 'otomobil', 'kuş', 'kedi', 'geyik',
'köpek', 'kurbağa', 'at', 'gemi', 'kamyon']
# Veri setinden birkaç görüntüyü görselleştirme
plt.figure(figsize=(10,10))
for i in range(25):
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(train_images[i])
plt.xlabel(class_names[train_labels[i][0]])
plt.show()
Evrişimsel Sinir Ağları CNN Modelinin Oluşturulması
Şimdi bir CNN modelini tanımlayacağız. TensorFlow 2.x’teki Keras API’sini kullanarak bu işlem oldukça kolaydır:
# CNN modelini oluşturma
model = models.Sequential()
# Birinci evrişim bloğu
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
# İkinci evrişim bloğu
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
# Üçüncü evrişim bloğu
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
# Densely connected katmanlar
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10)) # 10 sınıf için çıkış katmanı
# Model özetini görüntüleme
model.summary()
Yukarıdaki kodda:
- Üç evrişim bloğu oluşturduk. Her blok bir evrişim katmanı ve (ilk iki blokta) bir havuzlama katmanı içerir.
- Evrişim katmanlarını takiben bir Flatten katmanı ekleyerek çok boyutlu çıktıyı düzleştirdik.
- Son olarak, iki tamamen bağlı (Dense) katman ekledik. Son katman, 10 sınıfımızı temsil eden 10 nöron içeriyor.
Evrişimsel Sinir Ağları Modelin Eğitilmesi
Modelimizi derleyelim ve eğitelim:
# Modeli derleme
model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
# Modeli eğitme
history = model.fit(train_images, train_labels, epochs=10,
validation_data=(test_images, test_labels))
Burada:
- Adam optimizer kullandık
- Kayıp fonksiyonu olarak SparseCategoricalCrossentropy kullandık (çünkü etiketlerimiz kategorik değil sayısal)
- 10 epoch boyunca modeli eğittik
- Eğitim sırasında test verileri üzerinde doğrulama yaptık
Evrişimsel Sinir Ağları Modelin Değerlendirilmesi
Eğitim ve doğrulama performansını görselleştirelim:
# Eğitim ve doğrulama doğruluğunu görselleştirme
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Eğitim Doğruluğu')
plt.plot(history.history['val_accuracy'], label='Doğrulama Doğruluğu')
plt.xlabel('Epoch')
plt.ylabel('Doğruluk')
plt.ylim([0.5, 1])
plt.legend(loc='lower right')
# Eğitim ve doğrulama kaybını görselleştirme
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Eğitim Kaybı')
plt.plot(history.history['val_loss'], label='Doğrulama Kaybı')
plt.xlabel('Epoch')
plt.ylabel('Kayıp')
plt.legend(loc='upper right')
plt.show()
# Test veri seti üzerinde değerlendirme
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print(f"\nTest doğruluğu: {test_acc:.4f}")
Tahminlerin Görselleştirilmesi
Modelimizin birkaç test görüntüsü üzerinde nasıl performans gösterdiğini görelim:
# Modelden tahminler alma
predictions = model.predict(test_images)
# Tahmin sonuçlarını görselleştirme fonksiyonu
def plot_image(i, predictions_array, true_label, img):
true_label, img = true_label[i][0], img[i]
plt.grid(False)
plt.xticks([])
plt.yticks([])
plt.imshow(img)
predicted_label = np.argmax(predictions_array[i])
if predicted_label == true_label:
color = 'blue' # doğru tahmin
else:
color = 'red' # yanlış tahmin
plt.xlabel(f"{class_names[predicted_label]} ({class_names[true_label]})",
color=color)
def plot_value_array(i, predictions_array, true_label):
true_label = true_label[i][0]
plt.grid(False)
plt.xticks(range(10), class_names, rotation=45)
plt.yticks([])
thisplot = plt.bar(range(10), predictions_array[i], color="#777777")
plt.ylim([0, 1])
predicted_label = np.argmax(predictions_array[i])
thisplot[predicted_label].set_color('red')
thisplot[true_label].set_color('blue')
# Test veri setinden örnekleri görselleştirme
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
plt.subplot(num_rows, 2*num_cols, 2*i+1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(num_rows, 2*num_cols, 2*i+2)
plot_value_array(i, predictions, test_labels)
plt.tight_layout()
plt.show()
Evrişimsel Sinir Ağları İleri Seviye Teknikler
CNN’lerin performansını artırmak için kullanabileceğimiz bazı ileri seviye teknikler:
1. Veri Artırma (Data Augmentation)
Veri artırma, eğitim veri setindeki görüntüleri döndürerek, kaydırarak veya ölçeklendirerek çeşitlendirmenizi sağlar:
data_augmentation = tf.keras.Sequential([
layers.experimental.preprocessing.RandomFlip("horizontal"),
layers.experimental.preprocessing.RandomRotation(0.1),
layers.experimental.preprocessing.RandomZoom(0.1),
])
# Veri artırmayla model oluşturma
augmented_model = models.Sequential([
data_augmentation,
layers.Conv2D(32, 3, padding='same', activation='relu'),
layers.MaxPooling2D(),
layers.Conv2D(64, 3, padding='same', activation='relu'),
layers.MaxPooling2D(),
layers.Conv2D(128, 3, padding='same', activation='relu'),
layers.MaxPooling2D(),
layers.Dropout(0.2),
layers.Flatten(),
layers.Dense(64, activation='relu'),
layers.Dense(10)
])
augmented_model.compile(
optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy']
)
2. Transfer Öğrenme (Transfer Learning)
Önceden eğitilmiş bir modeli kullanarak daha iyi sonuçlar elde edebiliriz:
# MobileNetV2 temel modelini yükleme
base_model = tf.keras.applications.MobileNetV2(
input_shape=(160, 160, 3),
include_top=False,
weights='imagenet'
)
# Temel modeli dondurma (eğitilmesini engelleme)
base_model.trainable = False
# Transfer öğrenme modeli oluşturma
transfer_model = tf.keras.Sequential([
# Görüntülerimizi MobileNetV2'nin beklediği formata dönüştürme
tf.keras.layers.experimental.preprocessing.Resizing(160, 160),
tf.keras.layers.experimental.preprocessing.Rescaling(1./127.5, offset=-1),
# Temel model
base_model,
# Özel katmanlar
tf.keras.layers.GlobalAveragePooling2D(),
tf.keras.layers.Dense(10)
])
transfer_model.compile(
optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy']
)
3. Düzenlileştirme (Regularization)
Aşırı öğrenmeyi (overfitting) önlemek için düzenlileştirme teknikleri kullanabiliriz:
regularized_model = models.Sequential([
layers.Conv2D(32, 3, padding='same', activation='relu',
input_shape=(32, 32, 3),
kernel_regularizer=tf.keras.regularizers.l2(0.001)),
layers.MaxPooling2D(),
layers.Dropout(0.25), # Dropout ekleyerek overfitting'i azaltıyoruz
layers.Conv2D(64, 3, padding='same', activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(0.001)),
layers.MaxPooling2D(),
layers.Dropout(0.25),
layers.Conv2D(128, 3, padding='same', activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(0.001)),
layers.MaxPooling2D(),
layers.Dropout(0.4),
layers.Flatten(),
layers.Dense(128, activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(0.001)),
layers.Dropout(0.5),
layers.Dense(10)
])
regularized_model.compile(
optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy']
)
Sonuç
Bu eğitimde, TensorFlow ve Keras kullanarak evrişimli sinir ağlarının temel yapısını öğrendik ve adım adım bir CNN modeli geliştirdik. CIFAR-10 veri seti üzerinde uygulama yaparak modelin eğitimi, değerlendirmesi ve tahmin süreçlerini inceledik. Ayrıca, modelin performansını artıracak ileri seviye tekniklere de değindik.
CNN’ler, görüntü sınıflandırma, nesne tespiti ve görüntü segmentasyonu gibi birçok bilgisayarla görü görevinde temel yaklaşım haline gelmiştir. Bu temel bilgilerle, daha karmaşık ve özelleştirilmiş CNN mimarilerini keşfetmeye devam edebilirsiniz.
