Bases des réseaux neuronaux convolutifs
Ajoutez des couches Conv2D et MaxPooling pour les tâches de classification d’images.
Bases des réseaux neuronaux convolutifs est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.
Pourquoi utiliser des CNN pour les images ?
Un réseau dense traite les pixels indépendamment, ce qui fait perdre les relations spatiales. Un réseau neuronal convolutif (CNN) applique des filtres capables d’apprendre et qui se déplacent sur l’entrée, afin de détecter des motifs locaux tels que les contours, les textures et les formes, quelle que soit leur position. Cette invariance par translation et le partage des paramètres font des CNN la référence pour les données d’image.
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() — La couche principale
layer_conv_2d(filters, kernel_size, activation) applique à l’entrée filters noyaux 2D capables d’apprendre, de taille kernel_size. Chaque filtre apprend à détecter un type de motif spatial. La sortie a la forme (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) réduit les dimensions spatiales en sélectionnant la valeur maximale dans chaque fenêtre de regroupement. Cela a deux effets : le nombre de paramètres dans les couches suivantes diminue et une certaine invariance par translation est introduite (de petits déplacements ne modifient pas radicalement la sortie).
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 preservedEmpiler des couches convolutives
Les CNN plus profonds empilent plusieurs blocs convolution + regroupement. Les premières couches détectent des caractéristiques de bas niveau (contours, gradients) ; les couches plus profondes les combinent pour former des caractéristiques de haut niveau (formes, objets). Chaque couche convolutive augmente le nombre de filtres afin de compenser la réduction des dimensions spatiales.
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() convertit la sortie 3D du dernier bloc convolutif (height, width, filters) en un vecteur 1D. Elle fait le lien entre le socle d’extraction des caractéristiques (couches convolutives) et la tête de classification (couches denses).
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() dans les CNN
Dans les CNN, le dropout est généralement appliqué après la couche d’aplatissement et les couches denses, et non à l’intérieur des blocs convolutifs (où layer_spatial_dropout_2d() est préférable). Un taux de 0,25 à 0,5 après la première couche dense est courant.
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)Compiler et entraîner un CNN
Compilez et entraînez un CNN comme un réseau dense. Pour une classification multiclasse avec des étiquettes codées en indicateurs, utilisez 'categorical_crossentropy' ; pour des étiquettes entières, utilisez 'sparse_categorical_crossentropy'. Les CNN tirent souvent avantage d’un taux d’apprentissage légèrement inférieur à celui des réseaux denses.
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)Augmentation des données
L’entraînement de CNN sur de petits jeux de données conduit souvent au surapprentissage. L’augmentation des données agrandit artificiellement l’ensemble d’apprentissage en appliquant des transformations aléatoires (retournements, rotations, zooms) pendant l’entraînement. Dans keras3, utilisez layer_random_flip() et layer_random_rotation() comme couches de prétraitement à l’intérieur du modèle.
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)Évaluer le CNN
evaluate(model, x_test, y_test) renvoie la perte et la précision sur les données de test. Pour une analyse plus approfondie, utilisez predict() afin d’obtenir les probabilités des classes, puis construisez une matrice de confusion ou calculez les scores F1 par classe pour comprendre les difficultés du modèle.
# 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)Le concept d’apprentissage par transfert
Entraîner un CNN à partir de zéro nécessite de grands jeux de données. L’apprentissage par transfert réutilise des couches d’extraction de caractéristiques préentraînées sur ImageNet (par exemple VGG, ResNet, MobileNet) et n’entraîne qu’une tête de classification personnalisée. Dans keras, chargez une base préentraînée avec application_mobilenet_v2() et gelez ses couches.
# 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')
)Remplissage et pas de Conv2D
Deux arguments importants de layer_conv_2d : padding = 'same' ajoute des zéros autour de l’entrée afin que la sortie ait la même taille spatiale que l’entrée ; padding = 'valid' (valeur par défaut) réduit les dimensions de kernel_size - 1. strides = c(2,2) remplace le regroupement maximal en faisant glisser le filtre par pas de 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)Vérification rapide
Quel est l’objectif principal de layer_max_pooling_2d(pool_size = c(2, 2)) dans un CNN ?
Récapitulatif des CNN
Points clés des bases des réseaux neuronaux convolutifs :
- Les CNN utilisent des champs réceptifs locaux et le partage des paramètres pour traiter efficacement les images.
layer_conv_2d(filters, kernel_size, activation)extrait les caractéristiques spatiales.layer_max_pooling_2d(pool_size)réduit la résolution et fournit une invariance par translation.layer_flatten()fait le lien entre le socle convolutif et la tête du classificateur dense.layer_dropout(rate)régularise la tête de classification.- Les couches d’augmentation des données (
layer_random_flip(), etc.) réduisent le surapprentissage. - L’apprentissage par transfert avec des socles préentraînés est l’approche pratique pour les petits jeux de données.
# 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)Questions Fréquemment Posées
La leçon « Bases des réseaux neuronaux convolutifs » est-elle gratuite ?
Oui — le texte complet de « Bases des réseaux neuronaux convolutifs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Bases des réseaux neuronaux convolutifs » ?
Ajoutez des couches Conv2D et MaxPooling pour les tâches de classification d’images. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer R Academy ?
Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Bases des réseaux neuronaux convolutifs » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon R Academy ?
Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Configurer Keras et TensorFlow dans R
- Construire des modèles séquentiels
- Bases des réseaux neuronaux convolutifs
- Entraînement, validation et prévention du surapprentissage