0Pricing
R Academy · Lekcja

Podstawy konwolucyjnych sieci neuronowych

Dodawaj warstwy Conv2D i MaxPooling do zadań klasyfikacji obrazów.

Podstawy konwolucyjnych sieci neuronowych to bezpłatna lekcja R Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Dlaczego CNN do obrazów?

Sieć gęsta traktuje piksele niezależnie, przez co traci informacje o relacjach przestrzennych. Konwolucyjna sieć neuronowa (CNN) stosuje wyuczalne filtry, które przesuwają się po danych wejściowych i wykrywają lokalne wzorce, takie jak krawędzie, tekstury i kształty, niezależnie od ich położenia. Ta niezmienniczość translacyjna oraz współdzielenie parametrów sprawiają, że CNN są standardowym rozwiązaniem w przypadku danych obrazowych.

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() — podstawowa warstwa

layer_conv_2d(filters, kernel_size, activation) stosuje do danych wejściowych filters wyuczalnych jąder 2D o rozmiarze kernel_size. Każdy filtr uczy się wykrywać określony typ wzorca przestrzennego. Dane wyjściowe mają kształt (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) zmniejsza wymiary przestrzenne, wybierając maksymalną wartość w każdym oknie poolingu. Daje to dwa efekty: zmniejsza liczbę parametrów w kolejnych warstwach oraz wprowadza pewien stopień niezmienniczości translacyjnej (niewielkie przesunięcia nie zmieniają znacząco danych wyjściowych).

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

Układanie warstw konwolucyjnych

Głębsze CNN składają się z wielu bloków Conv+Pool. Wczesne warstwy wykrywają cechy niskiego poziomu (krawędzie, gradienty), a głębsze łączą je w cechy wysokiego poziomu (kształty, obiekty). Każda warstwa Conv zwiększa liczbę filtrów, aby skompensować zmniejszające się wymiary przestrzenne.

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() przekształca trójwymiarowe dane wyjściowe ostatniego bloku konwolucyjnego (height, width, filters) w wektor jednowymiarowy. Jest to połączenie między modułem ekstrakcji cech (warstwami konwolucyjnymi) a głowicą klasyfikacyjną (warstwami gęstymi).

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() w CNN

W CNN dropout jest zwykle stosowany za warstwą flatten i warstwami gęstymi, a nie wewnątrz bloków konwolucyjnych (w ich przypadku preferowany jest dropout przestrzenny layer_spatial_dropout_2d()). Często stosuje się współczynnik 0.25–0.5 za pierwszą warstwą gęstą.

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)

Kompilowanie i trenowanie CNN

Sieć CNN należy kompilować i trenować tak samo jak sieć gęstą. W przypadku klasyfikacji wieloklasowej z etykietami one-hot należy użyć 'categorical_crossentropy', a w przypadku etykiet całkowitoliczbowych — 'sparse_categorical_crossentropy'. CNN często korzystają z nieco mniejszej szybkości uczenia niż sieci gęste.

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)

Augmentacja danych

Trenowanie CNN na małych zbiorach danych często prowadzi do przeuczenia. Augmentacja danych sztucznie powiększa zbiór treningowy przez stosowanie losowych przekształceń (odbicia, obroty, powiększenia) podczas treningu. W keras3 należy użyć warstw wstępnego przetwarzania layer_random_flip() i layer_random_rotation() wewnątrz modelu.

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)

Ocena CNN

evaluate(model, x_test, y_test) zwraca funkcję straty i dokładność dla danych testowych. Aby przeprowadzić dokładniejszą analizę, należy użyć predict() do uzyskania prawdopodobieństw klas, a następnie utworzyć macierz pomyłek lub obliczyć wynik F1 dla każdej klasy, aby sprawdzić, z którymi przypadkami model ma trudności.

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

Koncepcja uczenia transferowego

Trenowanie CNN od podstaw wymaga dużych zbiorów danych. Uczenie transferowe ponownie wykorzystuje warstwy ekstrakcji cech wstępnie wytrenowane na ImageNet (np. VGG, ResNet, MobileNet), trenując tylko niestandardową głowicę klasyfikacyjną. W keras należy wczytać wstępnie wytrenowaną bazę za pomocą application_mobilenet_v2() i zamrozić jej warstwy.

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

Dopełnienie i kroki Conv2D

Dwa ważne argumenty layer_conv_2d: padding = 'same' dodaje zera wokół danych wejściowych, dzięki czemu dane wyjściowe mają taki sam rozmiar przestrzenny jak dane wejściowe; padding = 'valid' (wartość domyślna) zmniejsza wymiary o kernel_size - 1. strides = c(2,2) zastępuje max pooling, przesuwając filtr co 2 jednostki.

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

Szybkie sprawdzenie

Jaki jest główny cel użycia layer_max_pooling_2d(pool_size = c(2, 2)) w CNN?

Podsumowanie CNN

Najważniejsze informacje dotyczące podstaw konwolucyjnych sieci neuronowych:

  • CNN używają lokalnych pól recepcyjnych i współdzielenia parametrów, aby wydajnie przetwarzać obrazy.
  • layer_conv_2d(filters, kernel_size, activation) wydobywa cechy przestrzenne.
  • layer_max_pooling_2d(pool_size) zmniejsza rozdzielczość danych i zapewnia niezmienniczość translacyjną.
  • layer_flatten() łączy bazę konwolucyjną z gęstą głowicą klasyfikatora.
  • layer_dropout(rate) pełni funkcję regularyzacyjną w głowicy klasyfikacyjnej.
  • Warstwy augmentacji danych (layer_random_flip() itd.) ograniczają przeuczenie.
  • Uczenie transferowe z użyciem wstępnie wytrenowanych baz to praktyczne podejście w przypadku małych zbiorów danych.
# 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)

Często zadawane pytania

Czy lekcja „Podstawy konwolucyjnych sieci neuronowych” jest bezpłatna?

Tak — pełny tekst „Podstawy konwolucyjnych sieci neuronowych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Podstawy konwolucyjnych sieci neuronowych”?

Dodawaj warstwy Conv2D i MaxPooling do zadań klasyfikacji obrazów. Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Podstawy konwolucyjnych sieci neuronowych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Konfiguracja Keras i TensorFlow w R
  2. Budowanie modeli sekwencyjnych
  3. Podstawy konwolucyjnych sieci neuronowych
  4. Trenowanie, walidacja i zapobieganie przeuczeniu
← Powrót do R Academy