Couches récurrentes (SimpleRNN)

Les couches SimpleRNN sont des couches récurrentes utilisées dans les réseaux de neurones pour traiter des données séquentielles, comme des séries temporelles, du texte ou des signaux audio. L’objectif est de capturer les dépendances temporelles entre les éléments d’une séquence.

Le principe consiste à maintenir un état interne (mémoire) qui est mis à jour à chaque pas de la séquence. À chaque étape, la couche combine l’entrée actuelle avec l’état précédent pour produire une sortie et mettre à jour sa mémoire. Cela permet au réseau de retenir des informations sur les éléments précédents et d’influencer les prédictions futures.

Les couches SimpleRNN sont utilisées dans les tâches de classification, régression et génération de séquences, mais peuvent être limitées par des problèmes de disparition ou d’explosion du gradient sur de longues séquences.

En résumé, les couches SimpleRNN permettent d’apprendre des dépendances temporelles dans les séquences, offrant une mémoire limitée des informations passées pour l’apprentissage des patterns séquentiels.

Fonctions :

SimpleRNN()

SimpleRNN est une couche de réseau de neurones récurrent (RNN) basique qui traite des séquences de données en tenant compte de la dépendance temporelle. Elle possède un état caché mis à jour à chaque pas temporel, ce qui lui permet de mémoriser une partie de l'information des séquences précédentes. Elle est souvent utilisée pour des tâches de traitement de séries temporelles, texte ou séquences.

Importation :

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

Attributs :

Paramètre	Type	Description	Valeur par défaut
`units`	int	Nombre de neurones dans la couche RNN, définissant la taille de la sortie.	—
`activation`	str / callable	Fonction d'activation utilisée dans la couche.	`'tanh'`
`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 final en plus de la sortie.	`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 SimpleRNN, Dense
import numpy as np

# Données simulées : 100 séquences, chaque séquence de longueur 10, avec 8 features par pas de temps
X = np.random.rand(100, 10, 8)
y = np.random.randint(0, 2, size=(100, 1))

# Modèle simple avec SimpleRNN
model = Sequential()
model.add(SimpleRNN(16, activation='relu', input_shape=(10, 8)))
model.add(Dense(1, activation='sigmoid'))

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

Explication du code :

Importation des bibliothèques

On importe les couches `SimpleRNN` et `Dense` ainsi que `Sequential` de Keras pour construire le modèle.

Création des données

Les données simulées représentent 100 séquences. Chaque séquence contient 10 pas de temps, et chaque pas possède 8 caractéristiques.

Définition du modèle

La couche `SimpleRNN` contient 16 neurones et traite les séquences d’entrée. La couche dense finale à un neurone avec activation sigmoïde sert à la classification binaire.

Compilation

Le modèle est compilé avec la fonction de perte binaire et l’optimiseur Adam pour une tâche de classification binaire.