R Academy · Lektion

Grundlæggende convolutional neural networks

Tilføj Conv2D- og MaxPooling-lag til billedklassificeringsopgaver.

Lektion 3 af 413 trin

Grundlæggende convolutional neural networks er en gratis R Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i R Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. R Academy-kurset indeholder 4 lektioner i alt.

Hvorfor CNN'er til billeder?

Et tæt netværk behandler pixels uafhængigt af hinanden og mister de rumlige relationer. Et konvolutionelt neuralt netværk (CNN) anvender indlærbare filtre, der bevæger sig hen over inputtet og registrerer lokale mønstre som kanter, teksturer og former uanset deres placering. Denne translationsinvarians og deling af parametre gør CNN'er til standardvalget for billeddata.

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() — det grundlæggende lag

layer_conv_2d(filters, kernel_size, activation) anvender filters indlærbare 2D-kerner med størrelsen kernel_size på inputtet. Hvert filter lærer at registrere én type rumligt mønster. Outputtet har formen (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) reducerer de rumlige dimensioner ved at tage den største værdi i hvert pooling-vindue. Det opnår to ting: Det reducerer antallet af parametre i de efterfølgende lag, og det introducerer en grad af translationsinvarians (små forskydninger ændrer ikke outputtet markant).

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

Stakning af konvolutionelle lag

Dybere CNN'er stabler flere Conv+Pool-blokke. Tidlige lag registrerer funktioner på lavt niveau (kanter, gradienter), mens dybere lag kombinerer disse til funktioner på højt niveau (former, objekter). Hvert Conv-lag øger antallet af filtre for at kompensere for de mindre rumlige dimensioner.

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() konverterer 3D-outputtet fra den sidste konvolutionelle blok (height, width, filters) til en 1D-vektor. Det er forbindelsen mellem funktionsudtræksdelen (konvolutionelle lag) og klassifikationshovedet (tætte lag).

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() i CNN'er

I CNN'er anvendes dropout typisk efter flatten-laget og de tætte lag, ikke inde i de konvolutionelle blokke (hvor rumlig dropout med layer_spatial_dropout_2d() foretrækkes). En rate på 0,25-0,5 efter det første tætte lag er almindelig.

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)

Kompilering og træning af et CNN

Kompilér og træn et CNN på samme måde som et tæt netværk. Ved klassifikation med flere klasser og one-hot-mærkater skal du bruge 'categorical_crossentropy'; ved heltalsmærkater skal du bruge 'sparse_categorical_crossentropy'. CNN'er har ofte fordel af en lidt lavere læringsrate end tætte netværk.

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)

Dataforøgelse

Træning af CNN'er på små datasæt fører ofte til overtilpasning. Dataforøgelse udvider kunstigt træningssættet ved at anvende tilfældige transformationer (spejlvendinger, rotationer, zoom) under træningen. I keras3 kan du bruge layer_random_flip() og layer_random_rotation() som forbehandlingslag inde i modellen.

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)

Evaluering af CNN'et

evaluate(model, x_test, y_test) returnerer testtabet og nøjagtigheden. Brug predict() til en mere detaljeret analyse for at hente klassesandsynligheder, og opbyg derefter en forvekslingsmatrix eller beregn F1-scorer for hver klasse for at forstå, hvor modellen har problemer.

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

Konceptet bag transfer learning

Træning af et CNN fra bunden kræver store datasæt. Transfer learning genbruger funktionsudtrækslag, der er fortrænet på ImageNet (f.eks. VGG, ResNet, MobileNet), og træner kun et tilpasset klassifikationshoved. I keras indlæser du en fortrænet grundmodel med application_mobilenet_v2() og fastlåser dens lag.

# 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 og skridt i Conv2D

To vigtige argumenter til layer_conv_2d: padding = 'same' tilføjer nuller rundt om inputtet, så outputtet får samme rumlige størrelse som inputtet; padding = 'valid' (standard) reducerer dimensionerne med kernel_size - 1. strides = c(2,2) erstatter max pooling ved at lade filtret bevæge sig i skridt på 2.

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

Hurtigt tjek

Hvad er det primære formål med layer_max_pooling_2d(pool_size = c(2, 2)) i et CNN?

Besvar den i den interaktive lektion

Opsummering af CNN'er

Vigtige pointer fra grundlæggende konvolutionelle neurale netværk:

CNN'er bruger lokale receptive felter og deling af parametre til effektiv billedbehandling.
layer_conv_2d(filters, kernel_size, activation) udtrækker rumlige funktioner.
layer_max_pooling_2d(pool_size) reducerer opløsningen og giver translationsinvarians.
layer_flatten() forbinder den konvolutionelle grundmodel med det tætte klassifikationshoved.
layer_dropout(rate) regulariserer klassifikationshovedet.
Lag til dataforøgelse (layer_random_flip() osv.) reducerer overtilpasning.
Transfer learning med fortrænede grundmodeller er den praktiske tilgang til små datasæt.

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

Gratis at komme i gang

Lær R med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 43
Lektioner: 159

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Grundlæggende convolutional neural networks” gratis?

Ja — alle 3 lektioner i læringssporet R Academy, inklusive “Grundlæggende convolutional neural networks”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. R Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Grundlæggende convolutional neural networks”?

Tilføj Conv2D- og MaxPooling-lag til billedklassificeringsopgaver. Du øver dig i R Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på R Academy?

Der kræves ingen tidligere erfaring. R Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Grundlæggende convolutional neural networks”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne R Academy-lektion?

Ja. Alle R Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Opsætning af Keras og TensorFlow i R
Opbygning af sekventielle modeller
Grundlæggende convolutional neural networks
Træning, validering og forebyggelse af overfitting

← Tilbage til R Academy