R Academy · Lektion

Grundlagen konvolutionaler neuronaler Netze

Fügen Sie Conv2D- und MaxPooling-Schichten für Aufgaben der Bildklassifikation hinzu

Grundlagen konvolutionaler neuronaler Netze ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum CNNs für Bilder?

Ein dichtes Netzwerk behandelt Pixel unabhängig voneinander und verliert dadurch räumliche Beziehungen. Ein Convolutional Neural Network (CNN) verwendet lernbare Filter, die über die Eingabe gleiten und lokale Muster wie Kanten, Texturen und Formen unabhängig von ihrer Position erkennen. Diese Translationsinvarianz und die gemeinsame Nutzung von Parametern machen CNNs zum Standard für Bilddaten.

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() – Die zentrale Schicht

layer_conv_2d(filters, kernel_size, activation) wendet filters lernbare 2D-Kernel der Größe kernel_size auf die Eingabe an. Jeder Filter lernt, eine bestimmte Art räumlichen Musters zu erkennen. Die Ausgabe hat die Form (height, width, filters).

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) reduziert die räumlichen Dimensionen, indem es in jedem Pooling-Fenster den Maximalwert auswählt. Dadurch wird zum einen die Anzahl der Parameter in nachfolgenden Schichten verringert, zum anderen eine gewisse Translationsinvarianz eingeführt (kleine Verschiebungen verändern die Ausgabe nicht wesentlich).

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

Conv-Schichten stapeln

Tiefere CNNs stapeln mehrere Conv+Pool-Blöcke. Frühe Schichten erkennen Merkmale niedriger Ebene (Kanten, Gradienten); tiefere Schichten kombinieren diese zu Merkmalen höherer Ebene (Formen, Objekte). Jede Conv-Schicht erhöht die Anzahl der Filter, um die schrumpfenden räumlichen Dimensionen auszugleichen.

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() wandelt die 3D-Ausgabe des letzten Conv-Blocks (height, width, filters) in einen 1D-Vektor um. Dies ist die Verbindung zwischen dem Backbone zur Merkmalsextraktion (Convolutional-Schichten) und dem Klassifikationskopf (Dense-Schichten).

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)

layer_dropout() in CNNs

In CNNs wird Dropout normalerweise nach der Flatten-Schicht und den Dense-Schichten angewendet, nicht innerhalb der Convolutional-Blöcke (dort wird stattdessen räumliches Dropout mit layer_spatial_dropout_2d() bevorzugt). Eine Rate von 0.25–0.5 nach der ersten Dense-Schicht ist üblich.

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)

Ein CNN kompilieren und trainieren

Kompilieren und trainieren Sie ein CNN genauso wie ein dichtes Netzwerk. Verwenden Sie bei einer mehrklassigen Klassifikation mit One-Hot-Labels 'categorical_crossentropy' und bei Integer-Labels 'sparse_categorical_crossentropy'. CNNs profitieren häufig von einer etwas niedrigeren Lernrate als dichte Netzwerke.

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)

Datenaugmentation

Das Trainieren von CNNs mit kleinen Datensätzen führt häufig zu Overfitting. Datenaugmentation erweitert den Trainingsdatensatz künstlich, indem während des Trainings zufällige Transformationen (Spiegelungen, Drehungen, Zooms) angewendet werden. Verwenden Sie in keras3 layer_random_flip() und layer_random_rotation() als Preprocessing-Schichten innerhalb des Modells.

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)

Das CNN evaluieren

evaluate(model, x_test, y_test) gibt den Test-Loss und die Genauigkeit zurück. Für eine detailliertere Analyse können Sie mit predict() Klassenwahrscheinlichkeiten ermitteln und anschließend eine Konfusionsmatrix erstellen oder klassenweise F1-Scores berechnen, um zu erkennen, wo das Modell Schwierigkeiten hat.

# 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)

Das Konzept des Transfer Learnings

Das Trainieren eines CNN von Grund auf erfordert große Datensätze. Transfer Learning verwendet bereits auf ImageNet vortrainierte Schichten zur Merkmalsextraktion (z. B. VGG, ResNet, MobileNet) wieder und trainiert nur einen benutzerdefinierten Klassifikationskopf. Laden Sie in keras eine vortrainierte Basis mit application_mobilenet_v2() und frieren Sie deren Schichten ein.

# 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')
)

Padding und Strides bei Conv2D

Zwei wichtige Argumente von layer_conv_2d: padding = 'same' fügt Nullen um die Eingabe hinzu, sodass die Ausgabe dieselbe räumliche Größe wie die Eingabe hat; padding = 'valid' (Standard) reduziert die Dimensionen um kernel_size - 1. strides = c(2,2) ersetzt Max-Pooling, indem der Filter in Schritten von 2 über die Eingabe bewegt wird.

# '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)

Kurze Überprüfung

Was ist der Hauptzweck von layer_max_pooling_2d(pool_size = c(2, 2)) in einem CNN?

Zusammenfassung zu CNNs

Wichtige Erkenntnisse aus den Grundlagen der Convolutional Neural Networks:

CNNs verwenden lokale rezeptive Felder und gemeinsame Parameternutzung für eine effiziente Bildverarbeitung.
layer_conv_2d(filters, kernel_size, activation) extrahiert räumliche Merkmale.
layer_max_pooling_2d(pool_size) führt Downsampling durch und sorgt für Translationsinvarianz.
layer_flatten() verbindet das Conv-Backbone mit dem Dense-Klassifikationskopf.
layer_dropout(rate) regularisiert den Klassifikationskopf.
Schichten zur Datenaugmentation (layer_random_flip() usw.) verringern Overfitting.
Transfer Learning mit vortrainierten Backbones ist der praktische Ansatz für kleine Datensätze.

# 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)

Häufig gestellte Fragen

Ist die Lektion „Grundlagen konvolutionaler neuronaler Netze“ kostenlos?

Ja — der vollständige Text von „Grundlagen konvolutionaler neuronaler Netze“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Grundlagen konvolutionaler neuronaler Netze“?

Fügen Sie Conv2D- und MaxPooling-Schichten für Aufgaben der Bildklassifikation hinzu Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um R Academy zu starten?

Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Grundlagen konvolutionaler neuronaler Netze“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?

Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Keras und TensorFlow in R einrichten
Sequenzielle Modelle erstellen
Grundlagen konvolutionaler neuronaler Netze
Training, Validierung und Vermeidung von Overfitting

← Zurück zu R Academy