Le GRU (Gated Recurrent Unit) est un réseau récurrent à portes, plus simple que le LSTM : deux portes au lieu de trois, et pas de mémoire séparée. Il a moins de paramètres, s'entraîne plus vite et donne des résultats comparables dans bien des cas. C'est un bon premier choix pour modéliser une séquence avec peu de données.
Un analyste de marché met à jour son avis chaque matin. Il décide d'abord quelle part de son avis d'hier il garde, puis le complète avec les nouvelles du jour. Deux réglages suffisent.
Elle décide quelle part de l'état précédent sert à interpréter la nouvelle donnée. Proche de 0, le réseau repart presque de zéro pour ce pas.
Elle dose le mélange entre l'ancien état et un nouvel état candidat. Selon sa valeur, l'ancien état est conservé presque tel quel ou remplacé : c'est ce qui permet de retenir une information sur de nombreux pas.
Après les 20 derniers jours de bourse, l'état du GRU passe dans une couche de sortie qui prévoit l'amplitude du mouvement du lendemain.
Un cours de clôture quotidien. On en tire l'amplitude du mouvement de chaque jour (la valeur absolue du rendement), qui mesure la nervosité du marché. Les périodes agitées ont tendance à se suivre.
Le GRU lit les 20 derniers jours et prévoit l'amplitude attendue demain. La trésorerie ajuste ses limites de risque ou ses couvertures quand l'agitation prévue monte. Il ne s'agit pas de prévoir le sens du marché, seulement l'ampleur des mouvements.
La prévision est comparée à la moyenne des amplitudes des 20 derniers jours, sur des jours jamais vus : corrélation avec la réalité et erreur quadratique moyenne (RMSE). Battre cette référence est difficile ; si le GRU n'y parvient pas, la méthode simple ou un GARCH l'emporte.
Noms donnés pour Keras, identiques en R (keras3) et en Python.
La taille de l'état caché. 16 à 64 suffisent souvent sur des séries financières ou de capteurs. Commencer petit.
Le nombre de pas passés lus (ici 20 jours de bourse, environ un mois). Trop courte, elle manque les régimes ; trop longue, elle dilue le signal récent.
mse prévoit une moyenne, mae une médiane. Sur une amplitude, toujours positive, une sortie softplus évite les prévisions négatives.
Avec validation_split et un callback EarlyStopping, l'entraînement s'arrête quand l'erreur de validation ne baisse plus. Garder l'ordre du temps : la validation porte sur la fin de la période.
# Volatilité de marché : GRU en R
library(keras3)
cours <- read.csv("cours_bourse.csv")
rendement <- 100 * diff(log(cours$cloture)) # rendement quotidien en %
amplitude <- abs(rendement) # ampleur du mouvement, dans un sens ou dans l'autre
# Entrée : amplitudes des 20 derniers jours ; cible : amplitude du lendemain
fen <- 20
n <- length(amplitude) - fen
X <- array(0, dim = c(n, fen, 1))
for (i in 1:n) X[i, , 1] <- amplitude[i:(i + fen - 1)]
y <- amplitude[(fen + 1):length(amplitude)]
coupe <- 1000 # apprentissage sur les 1 000 premières fenêtres, test sur la suite
set_random_seed(42)
modele <- keras_model_sequential(input_shape = c(fen, 1))
modele <- layer_gru(modele, units = 16)
modele <- layer_dense(modele, units = 1, activation = "softplus")
compile(modele, optimizer = "adam", loss = "mse")
fit(modele, X[1:coupe, , , drop = FALSE], y[1:coupe], epochs = 30, batch_size = 32, validation_split = 0.1, verbose = 0)
# Référence à battre : la moyenne des amplitudes des 20 derniers jours
test <- (coupe + 1):n
prevision <- predict(modele, X[test, , , drop = FALSE], verbose = 0)[, 1]
reference <- rowMeans(X[test, , 1])
cat("Corrélation GRU / référence :", round(cor(prevision, y[test]), 3), "/", round(cor(reference, y[test]), 3), "\n")
cat("RMSE GRU / référence :", round(sqrt(mean((prevision - y[test])^2)), 3), "/", round(sqrt(mean((reference - y[test])^2)), 3), "\n")# Volatilité de marché : GRU en Python
import numpy as np
import pandas as pd
import keras
cours = pd.read_csv("cours_bourse.csv")
rendement = 100 * np.diff(np.log(cours["cloture"].values)) # rendement quotidien en %
amplitude = np.abs(rendement) # ampleur du mouvement, dans un sens ou dans l'autre
# Entrée : amplitudes des 20 derniers jours ; cible : amplitude du lendemain
fen = 20
X = np.array([amplitude[t - fen:t] for t in range(fen, len(amplitude))])[:, :, None]
y = amplitude[fen:]
coupe = 1000 # apprentissage sur les 1 000 premières fenêtres, test sur la suite
keras.utils.set_random_seed(42)
modele = keras.Sequential([keras.Input(shape=(fen, 1)), keras.layers.GRU(16),
keras.layers.Dense(1, activation="softplus")])
modele.compile(optimizer="adam", loss="mse")
modele.fit(X[:coupe], y[:coupe], epochs=30, batch_size=32, validation_split=0.1, verbose=0)
# Référence à battre : la moyenne des amplitudes des 20 derniers jours
prevision = modele.predict(X[coupe:], verbose=0).ravel()
reference = X[coupe:, :, 0].mean(axis=1)
for nom, p in [("GRU", prevision), ("Référence 20 jours", reference)]:
rmse = np.sqrt(np.mean((p - y[coupe:]) ** 2))
print(nom, ": corrélation", round(np.corrcoef(p, y[coupe:])[0, 1], 3), "| RMSE", round(rmse, 3), "pt de %")Le LSTM a trois portes et deux états : une mémoire à long terme et un état caché. Le GRU fusionne les deux en un seul état et n'a que deux portes. À taille égale, il a environ un quart de paramètres en moins. En pratique, aucun des deux ne gagne systématiquement : il faut tester.
Quand les données sont peu nombreuses, que le temps de calcul compte ou pour un premier essai. Le GRU converge souvent plus vite. Si le LSTM fait nettement mieux en validation sur vos données, on le garde.
Le sens du marché est quasiment imprévisible, avec un GRU comme avec toute autre méthode. En revanche, l'ampleur des mouvements est en partie prévisible, parce que les périodes agitées se suivent. C'est ce que fait le cas de cette fiche.
Trois portes et une mémoire séparée. Un peu plus de capacité sur les dépendances très longues, plus de paramètres.
Voir la fiche → la référence en volatilitéLe modèle statistique standard pour prévoir la volatilité quand les périodes agitées se suivent. Lisible et très répandu en gestion des risques.
Voir la fiche → la version sans portesLe réseau récurrent de base. Plus simple, mais il oublie vite le début des séquences.
Voir la fiche →Dataistudio forme les équipes au machine learning et à l'IA, sur des cas concrets.
Nous utilisons des cookies de mesure d'audience et de suivi publicitaire pour comprendre la fréquentation du site et l'efficacité de nos annonces. Rien n'est déposé sans votre accord. En savoir plus