— factory / algos ML / deep learning sur séquences

RÉSEAU DE NEURONES RÉCURRENT.

Un RNN (réseau de neurones récurrent) lit une séquence élément par élément, en gardant un résumé de ce qu'il a déjà vu. Il sert à prédire à partir d'un ordre d'événements : pages visitées, transactions, mesures successives. C'est la base historique du deep learning sur séquences, aujourd'hui remplacée en pratique par le LSTM, le GRU et les Transformers.

SéquencesDeep learningParcours clientClassificationNiveau : intermédiaire

FICHE D'IDENTITÉ

notes sur 5 · usage entreprise

PerformanceCorrect sur séquences courtes, oublie vite le début

InterprétabilitéMémoire interne faite de nombres sans sens métier

VitessePetit et rapide, mais lit les éléments un par un

Facilité de réglageApprentissage instable sur les longues séquences

Tolérance aux données brutesSéquences à encoder, à tronquer et à mettre à l'échelle

EN 30 SECONDES

Un vendeur suit un client dans le magasin. À chaque rayon visité, il met à jour son impression : « simple curieux », puis « intéressé », puis « prêt à acheter ». Il ne se souvient pas de chaque pas, seulement de son impression du moment.

1. On lit le premier élément

Le réseau reçoit la première page vue et calcule un état caché : un petit vecteur de nombres qui résume ce qu'il sait.

2. On combine avec ce qu'on savait déjà

À chaque page suivante, le nouvel état est calculé à partir de la page lue et de l'état précédent, avec les mêmes poids à chaque pas. D'où le nom de récurrent.

3. On décide à la fin

Après la dernière page lue, l'état final passe dans une couche de sortie qui donne une probabilité d'achat. L'entraînement ajuste les poids par rétropropagation à travers le temps.

LE CAS MÉTIER

parcours client · e-commerce

EN ENTRÉE

Les 4 premières pages de chaque session

3 000 sessions de navigation : accueil, catégorie, produit, panier, paiement, confirmation, sortie. On garde les 4 premières pages, codées en one-hot. Une session qui se termine plus tôt est complétée par des zéros.

EN SORTIE

Une probabilité d'achat en cours de visite

Moins d'une session sur dix aboutit à une confirmation de commande. Le modèle repère tôt celles qui en prennent le chemin : le site peut alors proposer une aide, et éviter de solliciter les visiteurs qui ne font que passer.

CE QU'ON MESURE

L'AUC, car les acheteurs sont rares

Avec si peu d'acheteurs, un modèle qui prédit « personne n'achète » a plus de 90 % d'exactitude et ne sert à rien. L'AUC mesure si les futurs acheteurs reçoivent un score plus élevé que les autres : 0,5 correspond au hasard, 1 à la perfection.

QUAND LE SORTIR, QUAND L'ÉVITER

OUI

Séquences courtes où l'ordre compte : premières pages d'une visite, derniers achats
Apprendre ce qu'est un réseau récurrent avant de passer au LSTM ou au GRU
Modèle très léger à embarquer sur un appareil peu puissant
Données séquentielles en flux, traitées élément par élément

NON

Séquences longues (plus de quelques dizaines de pas) : le RNN simple oublie le début, préférer un LSTM ou un GRU
Parcours sans mémoire, où seule la dernière page compte : une chaîne de Markov suffit et se lit mieux
Texte ou très longues séquences avec beaucoup de données : un Transformer fait mieux
Quelques centaines de séquences seulement : des variables résumées et un modèle d'arbres seront plus robustes

LES 4 RÉGLAGES QUI COMPTENT

Noms donnés pour Keras, identiques en R (keras3) et en Python.

units

La taille de l'état caché, donc de la mémoire. 16 à 64 suffisent pour des séquences simples. Plus grand : plus de capacité, plus de risque de surapprentissage.

Longueur de séquence

Le nombre d'éléments lus (ici 4 pages). Les séquences plus courtes sont complétées (padding), les plus longues tronquées. Un compromis entre information et prédiction précoce.

epochs et arrêt précoce

Le nombre de passages sur les données. Avec validation_split et un callback d'arrêt précoce (EarlyStopping), l'entraînement s'arrête quand l'erreur de validation ne baisse plus.

Type de cellule

SimpleRNN, LSTM ou GRU s'échangent en une ligne. Au-delà de quelques dizaines de pas, LSTM ou GRU sont presque toujours meilleurs.

LE CODE MINIMAL

jeu d'exemple : parcours_web.csv ↓

# Parcours web : RNN en R
library(keras3)

parcours <- read.csv("parcours_web.csv")
parcours <- parcours[order(parcours$id_session, parcours$etape), ]
sessions <- split(parcours$page, parcours$id_session)
pages <- c("accueil", "categorie", "produit", "panier", "paiement", "confirmation", "sortie")

# Entrée : les 4 premières pages en one-hot ; cible : achat confirmé ensuite
X <- array(0, dim = c(length(sessions), 4, length(pages)))
for (i in seq_along(sessions)) {
  debut <- head(sessions[[i]], 4)
  for (t in seq_along(debut)) X[i, t, match(debut[t], pages)] <- 1
}
y <- as.numeric(sapply(sessions, function(s) "confirmation" %in% s))

set_random_seed(42)  # fixe aussi la graine R utilisée par sample()
idx <- sample(length(y), round(0.7 * length(y)))
modele <- keras_model_sequential(input_shape = c(4, length(pages)))
modele <- layer_simple_rnn(modele, units = 16)
modele <- layer_dense(modele, units = 1, activation = "sigmoid")
compile(modele, optimizer = "adam", loss = "binary_crossentropy", metrics = list(metric_auc()))
fit(modele, X[idx, , ], y[idx], epochs = 30, batch_size = 64, verbose = 0)
print(evaluate(modele, X[-idx, , ], y[-idx], verbose = 0))

# Parcours web : RNN en Python
import numpy as np
import pandas as pd
import keras
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score

parcours = pd.read_csv("parcours_web.csv").sort_values(["id_session", "etape"])
pages = ["accueil", "categorie", "produit", "panier", "paiement", "confirmation", "sortie"]
sessions = parcours.groupby("id_session")["page"].apply(list)

# Entrée : les 4 premières pages en one-hot ; cible : achat confirmé ensuite
X = np.zeros((len(sessions), 4, len(pages)))
for i, s in enumerate(sessions):
    for t, page in enumerate(s[:4]):
        X[i, t, pages.index(page)] = 1
y = np.array([int("confirmation" in s) for s in sessions])
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)

keras.utils.set_random_seed(42)
modele = keras.Sequential([keras.Input(shape=(4, len(pages))), keras.layers.SimpleRNN(16),
                           keras.layers.Dense(1, activation="sigmoid")])
modele.compile(optimizer="adam", loss="binary_crossentropy")
modele.fit(X_train, y_train, epochs=30, batch_size=64, verbose=0)
proba = modele.predict(X_test, verbose=0).ravel()
print("AUC test :", round(roc_auc_score(y_test, proba), 3))

QUESTIONS FRÉQUENTES

Qu'est-ce que le problème du gradient qui s'évanouit ?

Pour apprendre, le RNN propage l'erreur en arrière à travers chaque pas de la séquence. À chaque pas, ce signal est multiplié par des nombres souvent inférieurs à 1 : sur une longue séquence, il devient presque nul et le début de la séquence n'est plus appris. Le LSTM et le GRU ont été conçus pour corriger ce défaut.

Quelle différence entre RNN, LSTM et GRU ?

Les trois lisent la séquence pas à pas. Le RNN simple n'a qu'un état qui est entièrement recalculé à chaque pas. Le LSTM ajoute une mémoire séparée et trois portes qui contrôlent ce qu'on garde, ajoute et transmet. Le GRU en est une version simplifiée à deux portes.

Les RNN sont-ils encore utilisés ?

Le RNN simple sert surtout à l'enseignement et à des modèles très légers. Les LSTM et GRU restent utilisés sur des séries temporelles et des données de capteurs. Sur le texte, les Transformers les ont largement remplacés.