Couches récurrentes (GRU)

Les couches GRU (Gated Recurrent Unit) sont des couches récurrentes utilisées dans les réseaux de neurones pour traiter des données séquentielles et capturer des dépendances à court et long terme. L’objectif est de conserver les informations pertinentes tout en simplifiant la structure par rapport aux LSTM.

Le principe consiste à utiliser des unités composées de deux portes principales : la porte de mise à jour et la porte de réinitialisation. Ces portes régulent le flux d’information, décidant quelles informations mémoriser et lesquelles oublier, permettant ainsi au réseau de conserver les patterns importants tout au long de la séquence. Les GRU sont généralement plus rapides à entraîner que les LSTM tout en offrant des performances comparables.

Les couches GRU sont utilisées dans les tâches de classification, génération de séquences, traduction automatique, reconnaissance vocale ou analyse de séries temporelles.

En résumé, les couches GRU permettent d’apprendre efficacement des dépendances séquentielles tout en réduisant la complexité par rapport aux LSTM, offrant une mémoire adaptée aux patterns temporels.

Fonctions :

GRU()

GRU (Gated Recurrent Unit) est une couche de réseau de neurones récurrent conçue pour capturer les dépendances dans les données séquentielles, similaire à LSTM mais plus simple. Elle utilise deux portes (update et reset) pour contrôler le flux d'information, ce qui réduit la complexité tout en conservant une bonne capacité à modéliser des séquences à long terme.

Importation :

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import GRU, Dense
import numpy as np

Attributs :

Paramètre	Type	Description	Valeur par défaut
`units`	int	Nombre de neurones dans la couche GRU, définissant la taille de la sortie.	—
`activation`	str / callable	Fonction d'activation pour la cellule, souvent `'tanh'`.	`'tanh'`
`recurrent_activation`	str / callable	Fonction d'activation pour les portes récurrentes, généralement `'sigmoid'`.	`'sigmoid'`
`return_sequences`	bool	Si `True`, retourne la sortie à chaque pas de temps (séquence complète).	`False`
`return_state`	bool	Si `True`, retourne également l'état caché final.	`False`
`go_backwards`	bool	Si `True`, traite la séquence en ordre inverse.	`False`
`stateful`	bool	Si `True`, conserve l’état entre les lots d’entraînement.	`False`

Exemple de code :

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import GRU, Dense
import numpy as np

# Données simulées : 50 séquences, chaque séquence de longueur 20, avec 5 features par pas de temps
X = np.random.rand(50, 20, 5)
y = np.random.randint(0, 3, size=(50, 1))

# Modèle simple avec GRU
model = Sequential()
model.add(GRU(32, activation='tanh', input_shape=(20, 5)))
model.add(Dense(3, activation='softmax'))

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.summary()

Explication du code :

Importation des bibliothèques

On importe `GRU`, `Dense` et `Sequential` depuis Keras pour construire le modèle.

Création des données

Les données simulées consistent en 50 séquences, chaque séquence contenant 20 pas de temps avec 5 caractéristiques par pas.

Définition du modèle

Une couche GRU avec 32 neurones est utilisée pour traiter les séquences. Une couche dense finale à 3 neurones avec activation softmax est ajoutée pour la classification multi-classes.

Compilation

Le modèle est compilé avec la perte catégorielle creuse et l’optimiseur Adam pour l'entraînement.