R Academy · Leçon

Construire des modèles séquentiels

Empilez des couches Dense, appliquez des fonctions d’activation et compilez avec une fonction de perte et un optimiseur.

Construire des modèles séquentiels est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Le modèle séquentiel

Un modèle séquentiel est une succession linéaire de couches, où chaque couche possède exactement un tenseur d’entrée et un tenseur de sortie. Il s’agit du type de modèle Keras le plus simple, qui couvre la majorité des cas d’utilisation pratiques : classifieurs à propagation avant, modèles de régression et CNN/RNN élémentaires.

library(keras)

# An empty sequential model
model <- keras_model_sequential()
print(model)

# Or specify the input shape upfront
model <- keras_model_sequential(input_shape = c(20))
print(model)

layer_dense() — Couche entièrement connectée

layer_dense(units, activation) ajoute une couche entièrement connectée (dense), dans laquelle chaque neurone d’entrée est connecté à chaque neurone de sortie. L’argument units définit la dimension de sortie. activation applique une non-linéarité : 'relu' est la valeur habituelle pour les couches cachées.

library(keras)

model <- keras_model_sequential(input_shape = c(30)) |>
  layer_dense(units = 128, activation = 'relu') |>
  layer_dense(units = 64,  activation = 'relu') |>
  layer_dense(units = 1,   activation = 'sigmoid')

# Print architecture
summary(model)

Fonctions d’activation de la couche de sortie

L’activation de la dernière couche dépend de la tâche :

'sigmoid' : classification binaire (produit une probabilité comprise entre 0 et 1)
'softmax' : classification multiclasse (produit des probabilités dont la somme vaut 1)
'linear' ou aucune activation : régression (produit des prédictions à valeurs réelles)

# Binary classification
binary_model <- keras_model_sequential(input_shape = c(20)) |>
  layer_dense(64, activation = 'relu') |>
  layer_dense(1,  activation = 'sigmoid')   # P(class=1)

# Multi-class (10 classes)
multi_model <- keras_model_sequential(input_shape = c(20)) |>
  layer_dense(64,  activation = 'relu') |>
  layer_dense(10,  activation = 'softmax')  # P per class

# Regression
reg_model <- keras_model_sequential(input_shape = c(20)) |>
  layer_dense(64, activation = 'relu') |>
  layer_dense(1,  activation = 'linear')   # raw value

compile() — Perte, optimiseur, métriques

compile(loss, optimizer, metrics) configure le processus d’apprentissage. Combinaisons courantes :

Binaire : loss = 'binary_crossentropy', metrics = 'accuracy'
Multiclasse : loss = 'categorical_crossentropy'
Régression : loss = 'mse', metrics = 'mae'

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

# Check configuration
model$loss
model$optimizer$get_config()

optimizer_adam()

Adam (estimation adaptative des moments) est l’optimiseur par défaut pour la plupart des tâches d’apprentissage profond. Il adapte le taux d’apprentissage pour chaque paramètre en utilisant des estimations des premier et deuxième moments des gradients. Le taux d’apprentissage par défaut de 0,001 constitue un bon point de départ pour la plupart des problèmes.

# Adam with default settings
model |> compile(
  optimizer = 'adam',
  loss = 'binary_crossentropy',
  metrics = 'accuracy'
)

# Customised Adam
model |> compile(
  optimizer = optimizer_adam(
    learning_rate = 0.0005,
    beta_1  = 0.9,
    beta_2  = 0.999,
    epsilon = 1e-7
  ),
  loss    = 'binary_crossentropy',
  metrics = 'accuracy'
)

fit() — Entraîner le modèle

fit(model, x, y, epochs, batch_size, validation_split) entraîne le modèle. Chaque époque correspond à un parcours complet des données d’entraînement. La taille du lot détermine combien d’échantillons sont traités avant chaque mise à jour des poids. La fonction renvoie un objet d’historique.

# Prepare example data
x_train <- matrix(rnorm(1000 * 20), nrow = 1000)
y_train <- sample(c(0, 1), 1000, replace = TRUE)

history <- model |> fit(
  x         = x_train,
  y         = y_train,
  epochs    = 20,
  batch_size = 32,
  validation_split = 0.2,  # reserve 20% for validation
  verbose   = 1
)

plot(history)

Régularisation des couches — Dropout

layer_dropout(rate) met aléatoirement à 0 une fraction rate des unités d’entrée pendant l’entraînement. Cela empêche les neurones de s’adapter trop étroitement les uns aux autres et constitue un puissant mécanisme de régularisation. Le dropout est actif uniquement pendant l’entraînement, et non pendant l’inférence.

model <- keras_model_sequential(input_shape = c(784)) |>
  layer_dense(512, activation = 'relu') |>
  layer_dropout(rate = 0.4) |>
  layer_dense(256, activation = 'relu') |>
  layer_dropout(rate = 0.3) |>
  layer_dense(10,  activation = 'softmax')

summary(model)

Régularisation des poids avec L1 et L2

Régularisez les couches individuellement à l’aide de kernel_regularizer afin de pénaliser les poids élevés. L2 (ridge) pénalise la somme des carrés des poids ; L1 (lasso) pénalise les valeurs absolues et induit la parcimonie. Les deux sont disponibles via regularizer_l2() et regularizer_l1().

model <- keras_model_sequential(input_shape = c(100)) |>
  layer_dense(
    units = 64,
    activation = 'relu',
    kernel_regularizer = regularizer_l2(l = 0.01)
  ) |>
  layer_dense(
    units = 32,
    activation = 'relu',
    kernel_regularizer = regularizer_l1_l2(l1 = 1e-4, l2 = 1e-3)
  ) |>
  layer_dense(1, activation = 'sigmoid')

summary(model)

Normalisation par lots

layer_batch_normalization() normalise les activations de la couche précédente pour chaque mini-lot. Cela stabilise l’entraînement, permet d’utiliser des taux d’apprentissage plus élevés et agit comme un léger mécanisme de régularisation. Placez-la après layer_dense() et avant la fonction d’activation, ou après l’activation : les deux pratiques sont utilisées en pratique.

model <- keras_model_sequential(input_shape = c(100)) |>
  layer_dense(256, use_bias = FALSE) |>
  layer_batch_normalization() |>
  layer_activation('relu') |>
  layer_dense(128, use_bias = FALSE) |>
  layer_batch_normalization() |>
  layer_activation('relu') |>
  layer_dense(1, activation = 'sigmoid')

summary(model)

evaluate() et predict()

evaluate(model, x_test, y_test) calcule la perte et les métriques sur les données de test. predict(model, x_new) génère des prédictions brutes — des probabilités pour la classification. Les deux fonctions acceptent des matrices numériques et renvoient des valeurs cohérentes, natives de R.

x_test <- matrix(rnorm(200 * 20), nrow = 200)
y_test <- sample(c(0, 1), 200, replace = TRUE)

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

# Generate predictions
prob_preds <- model |> predict(x_test)
class_preds <- ifelse(prob_preds > 0.5, 1, 0)
table(class_preds, y_test)

Enregistrer et charger des modèles

Enregistrez un modèle compilé et entraîné avec save_model_tf(model, 'path') (format TF SavedModel, recommandé) ou save_model_hdf5(model, 'model.h5'). Rechargez-le avec load_model_tf() ou load_model_hdf5(). Le modèle chargé conserve les paramètres de compilation et peut immédiatement effectuer des prédictions ou poursuivre son entraînement.

# Save in TensorFlow SavedModel format (recommended)
save_model_tf(model, '/tmp/my_dense_model')

# Reload
loaded <- load_model_tf('/tmp/my_dense_model')

# Confirm predictions match
new_preds <- loaded |> predict(x_test)
all.equal(prob_preds, new_preds)  # TRUE

Vérification rapide

Lors de la construction d’un modèle séquentiel pour un problème de classification à 5 classes, quelle fonction d’activation et quel nombre d’unités la couche de sortie doit-elle utiliser ?

Récapitulatif des modèles séquentiels

Points clés de la construction de modèles séquentiels :

keras_model_sequential() crée une structure linéaire de couches.
layer_dense(units, activation) est la couche entièrement connectée principale.
Activation de sortie : 'sigmoid' (binaire), 'softmax' (multiclasse), 'linear' (régression).
compile(loss, optimizer, metrics) configure le processus d’apprentissage.
fit(model, x, y, epochs, batch_size, validation_split) entraîne le modèle.
Régularisation : layer_dropout(rate), regularizer_l2(), layer_batch_normalization().
Enregistrez avec save_model_tf() et chargez avec load_model_tf().

library(keras)

model <- keras_model_sequential(input_shape = c(30)) |>
  layer_dense(128, activation = 'relu') |>
  layer_dropout(0.4) |>
  layer_dense(64, activation = 'relu') |>
  layer_dropout(0.3) |>
  layer_dense(1, activation = 'sigmoid')

model |> compile(
  optimizer = optimizer_adam(0.001),
  loss      = 'binary_crossentropy',
  metrics   = 'accuracy'
)

history <- model |> fit(
  x_train, y_train,
  epochs = 30, batch_size = 64,
  validation_split = 0.2, verbose = 0
)
plot(history)

Questions Fréquemment Posées

La leçon « Construire des modèles séquentiels » est-elle gratuite ?

Oui — le texte complet de « Construire des modèles séquentiels » 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 « Construire des modèles séquentiels » ?

Empilez des couches Dense, appliquez des fonctions d’activation et compilez avec une fonction de perte et un optimiseur. 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 2 sur 4.

Combien de temps prend la leçon « Construire des modèles séquentiels » ?

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

← Retour à R Academy