R Academy · Ders

Evrişimli Sinir Ağlarının Temelleri

Görüntü sınıflandırma görevleri için Conv2D ve MaxPooling katmanları ekleyin.

3. ders / 413 adım

Evrişimli Sinir Ağlarının Temelleri, CoddyKit'te ücretsiz bir R Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, R Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. R Academy kursu toplamda 4 dersten oluşur.

Görüntüler için Neden CNN?

Yoğun bir ağ, pikselleri birbirinden bağımsız ele alır ve uzamsal ilişkileri kaybeder. Evrişimli sinir ağı (CNN), girdi üzerinde kayan ve öğrenilebilir süzgeçler uygulayarak konumdan bağımsız şekilde kenarlar, dokular ve şekiller gibi yerel örüntüleri algılar. Bu öteleme değişmezliği ve parametre paylaşımı, CNN'leri görüntü verileri için altın standart hâline getirir.

library(keras)

# Images are 3D tensors: (height, width, channels)
# MNIST: (28, 28, 1) — grayscale
# CIFAR-10: (32, 32, 3) — RGB

# Reshape flat vectors into image tensors
mnist <- dataset_mnist()
x_train <- array_reshape(mnist$train$x / 255, c(-1, 28, 28, 1))
y_train <- to_categorical(mnist$train$y, 10)

cat('Input shape:', dim(x_train))

layer_conv_2d() — Temel Katman

layer_conv_2d(filters, kernel_size, activation), boyutu kernel_size olan filters adet öğrenilebilir 2B çekirdeği girdiye uygular. Her süzgeç, bir uzamsal örüntü türünü algılamayı öğrenir. Çıktının şekli (height, width, filters) olur.

library(keras)

# First conv layer: 32 filters of 3x3
model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(
    filters     = 32,
    kernel_size = c(3, 3),
    activation  = 'relu',
    padding     = 'same'  # keep spatial dimensions
  )

summary(model)  # output: (None, 28, 28, 32)

layer_max_pooling_2d()

layer_max_pooling_2d(pool_size), her havuzlama penceresindeki en büyük değeri alarak uzamsal boyutları küçültür. Bunun iki sonucu vardır: sonraki katmanlardaki parametre sayısını azaltır ve belirli ölçüde öteleme değişmezliği sağlar (küçük kaymalar çıktıyı büyük ölçüde değiştirmez).

model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, kernel_size = c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(pool_size = c(2, 2))

summary(model)
# After pooling: (None, 13, 13, 32)
# Spatial dims halved, channel count preserved

Evrişim Katmanlarını Yığma

Daha derin CNN'ler birden çok Evrişim+Havuzlama bloğunu art arda kullanır. İlk katmanlar düşük düzeyli özellikleri (kenarlar, gradyanlar) algılar; daha derin katmanlar bunları yüksek düzeyli özelliklere (şekiller, nesneler) dönüştürür. Her Evrişim katmanı, küçülen uzamsal boyutları telafi etmek için süzgeç sayısını artırır.

model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
  layer_conv_2d(32, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2)) |>   # 16x16
  layer_conv_2d(64, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2)) |>   # 8x8
  layer_conv_2d(128, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2))      # 4x4

summary(model)

layer_flatten()

layer_flatten(), son evrişim bloğunun (height, width, filters) biçimindeki 3B çıktısını 1B vektöre dönüştürür. Bu katman, özellik çıkarma gövdesi (evrişim katmanları) ile sınıflandırma başlığı (yoğun katmanlar) arasındaki bağlantıdır.

model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_conv_2d(64, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_flatten() |>     # 3D -> 1D vector
  layer_dense(128, activation = 'relu') |>
  layer_dense(10, activation = 'softmax')

summary(model)

CNN'lerde layer_dropout()

CNN'lerde dropout genellikle evrişim bloklarının içinde değil, düzleştirme katmanından ve yoğun katmanlardan sonra uygulanır. Evrişim bloklarının içinde uzamsal dropout layer_spatial_dropout_2d() tercih edilir. İlk yoğun katmandan sonra 0,25-0,5 oranı yaygın bir seçimdir.

model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_conv_2d(64, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_flatten() |>
  layer_dense(128, activation = 'relu') |>
  layer_dropout(rate = 0.5) |>    # regularise the classifier head
  layer_dense(10, activation = 'softmax')

summary(model)

Bir CNN'i Derleme ve Eğitme

Bir CNN'i de yoğun bir ağ gibi derleyip eğitebilirsiniz. Tek-sıcak etiketli çok sınıflı sınıflandırma için 'categorical_crossentropy', tamsayı etiketler için 'sparse_categorical_crossentropy' kullanın. CNN'ler, yoğun ağlara göre genellikle biraz daha düşük öğrenme oranından yararlanır.

model |> compile(
  optimizer = optimizer_adam(learning_rate = 0.0005),
  loss      = 'categorical_crossentropy',
  metrics   = c('accuracy')
)

history <- model |> fit(
  x = x_train,
  y = y_train,
  epochs     = 10,
  batch_size = 64,
  validation_split = 0.1,
  verbose = 1
)

plot(history)

Veri Çoğaltma

CNN'leri küçük veri kümeleri üzerinde eğitmek çoğu zaman aşırı öğrenmeye yol açar. Veri çoğaltma, eğitim sırasında rastgele dönüşümler (çevirme, döndürme, yakınlaştırma) uygulayarak eğitim kümesini yapay olarak genişletir. keras3'te layer_random_flip() ve layer_random_rotation() işlevlerini model içinde ön işleme katmanları olarak kullanın.

model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
  # Data augmentation layers (only active during training)
  layer_random_flip('horizontal') |>
  layer_random_rotation(factor = 0.1) |>
  layer_random_zoom(height_factor = 0.1) |>
  # CNN backbone
  layer_conv_2d(32, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_flatten() |>
  layer_dense(10, activation = 'softmax')

summary(model)

CNN'i Değerlendirme

evaluate(model, x_test, y_test), sınama kaybını ve doğruluğunu döndürür. Daha derin bir çözümleme için sınıf olasılıklarını almak üzere predict() kullanın; ardından modelin hangi durumlarda zorlandığını anlamak için bir hata matrisi oluşturun veya sınıf başına F1 puanlarını hesaplayın.

# Evaluate on test set
test_scores <- model |> evaluate(x_test, y_test, verbose = 0)
cat('Test accuracy:', test_scores['accuracy'])

# Get predicted classes
prob_matrix <- model |> predict(x_test)
pred_classes <- max.col(prob_matrix) - 1  # 0-indexed
true_classes <- mnist$test$y

# Confusion matrix
table(Predicted = pred_classes, True = true_classes)

Aktarım Öğrenmesi Kavramı

Bir CNN'i sıfırdan eğitmek büyük veri kümeleri gerektirir. Aktarım öğrenmesi, ImageNet üzerinde önceden eğitilmiş özellik çıkarma katmanlarını (ör. VGG, ResNet, MobileNet) yeniden kullanır ve yalnızca özel bir sınıflandırma başlığını eğitir. keras'te application_mobilenet_v2() ile önceden eğitilmiş bir temel yükleyin ve katmanlarını dondurun.

# Load MobileNetV2 pretrained on ImageNet
base_model <- application_mobilenet_v2(
  weights      = 'imagenet',
  include_top  = FALSE,          # remove original classifier head
  input_shape  = c(224, 224, 3)
)

# Freeze pretrained weights
base_model$trainable <- FALSE

# Add custom classifier head
model <- keras_model(
  inputs  = base_model$input,
  outputs = base_model$output |>
    layer_global_average_pooling_2d() |>
    layer_dense(128, activation = 'relu') |>
    layer_dense(5, activation = 'softmax')
)

Conv2D Dolgulama ve Adımlama

İki önemli layer_conv_2d bağımsız değişkeni vardır: padding = 'same', çıktının girdiyle aynı uzamsal boyuta sahip olması için girdinin çevresine sıfırlar ekler; padding = 'valid' (varsayılan), boyutları kernel_size - 1 kadar küçültür. strides = c(2,2), süzgeci 2'şer adımlarla kaydırarak en büyük havuzlamanın yerini alır.

# 'same' padding: output = input size
conv_same <- layer_conv_2d(filters = 32, kernel_size = c(3, 3),
                           padding = 'same')

# Strided convolution instead of pooling
conv_strided <- layer_conv_2d(filters = 64, kernel_size = c(3, 3),
                              strides = c(2, 2),  # halves spatial dims
                              padding = 'same')

# Model using strides instead of max pooling
model2 <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, c(3,3), strides = c(2,2), activation = 'relu',
                padding = 'same') |>
  layer_conv_2d(64, c(3,3), strides = c(2,2), activation = 'relu',
                padding = 'same') |>
  layer_flatten() |>
  layer_dense(10, activation = 'softmax')
summary(model2)

Hızlı Kontrol

Bir CNN'de layer_max_pooling_2d(pool_size = c(2, 2)) işlevinin temel amacı nedir?

İnteraktif derste cevapla

CNN'lere Genel Bakış

Evrişimli Sinir Ağlarının Temelleri konusundan temel çıkarımlar:

CNN'ler, verimli görüntü işleme için yerel alıcı alanlar ve parametre paylaşımı kullanır.
layer_conv_2d(filters, kernel_size, activation), uzamsal özellikleri çıkarır.
layer_max_pooling_2d(pool_size), örnekleme oranını düşürür ve öteleme değişmezliği sağlar.
layer_flatten(), evrişim gövdesi ile yoğun sınıflandırıcı başlığını birbirine bağlar.
layer_dropout(rate), sınıflandırma başlığını düzenlileştirir.
Veri çoğaltma katmanları (layer_random_flip() vb.) aşırı öğrenmeyi azaltır.
Önceden eğitilmiş gövdelerle aktarım öğrenmesi, küçük veri kümeleri için uygulanabilir yaklaşımdır.

# Standard CNN architecture for image classification
model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
  layer_conv_2d(32,  c(3,3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2,2)) |>
  layer_conv_2d(64,  c(3,3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2,2)) |>
  layer_conv_2d(128, c(3,3), activation = 'relu', padding = 'same') |>
  layer_flatten() |>
  layer_dense(256, activation = 'relu') |>
  layer_dropout(0.5) |>
  layer_dense(num_classes, activation = 'softmax')

model |> compile('adam', 'categorical_crossentropy', 'accuracy')
summary(model)

Başlamak ücretsiz

Yapay zeka eğitmeniyle R öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar: 43
Dersler: 159

Ücretsiz öğrenmeye başla Tüm kursu görüntüle

Sıkça Sorulan Sorular

“Evrişimli Sinir Ağlarının Temelleri” dersi ücretsiz mi?

Evet — “Evrişimli Sinir Ağlarının Temelleri” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve R Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. R Academy kursu toplamda 4 dersten oluşur.

“Evrişimli Sinir Ağlarının Temelleri” dersinde ne öğreneceğim?

Görüntü sınıflandırma görevleri için Conv2D ve MaxPooling katmanları ekleyin. R Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

R Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te R Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“Evrişimli Sinir Ağlarının Temelleri” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu R Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her R Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

R'de Keras ve TensorFlow Kurulumu
Sıralı Modeller Oluşturma
Evrişimli Sinir Ağlarının Temelleri
Eğitim, Doğrulama ve Aşırı Öğrenmeyi Önleme

← R Academy Sayfasına Dön