Les Couches des NN

Les réseaux de neurones sont un composant clé de nombreux modèles de NLP. Les réseaux de
neurones sont construits en empilant plusieurs couches ensemble pour former un modèle qui peut
apprendre à partir de données. Voici une explication des différentes couches couramment utilisées
dans les modèles de NLP :

1. Couche d'entrée : La couche d'entrée est la première couche du modèle. Elle prend les
données d'entrée sous forme de texte brut et les convertit en une représentation numérique
que le modèle peut comprendre.

Cette couche prend une séquence de mots sous forme de texte brut et les convertit en une matrice
de taille (n x d), où n est le nombre de mots dans la séquence et d est la dimension de chaque mot.
Cette matrice est ensuite transmise à la couche suivante

2. Couche d'embedding : La couche d'embedding prend la représentation numérique de la

couche d'entrée et la convertit en une représentation vectorielle dense. Cela permet au
modèle de mieux comprendre la signification des mots en les regroupant en fonction de leur
contexte et de leur utilisation.

La couche d'embedding transforme la matrice d'entrée en une nouvelle matrice de taille (n x e), où e
est la dimension de l'espace vectoriel d'embedding. La transformation se fait en multipliant chaque
mot de la matrice d'entrée par une matrice de poids d'embedding de taille (d x e).

3. Couche de convolution : La couche de convolution utilise un noyau de convolution pour

extraire des informations de la représentation vectorielle dense créée par la couche
d'embedding. Cela permet de détecter des motifs dans le texte, tels que des groupes de
mots récurrents.

La couche de convolution utilise une opération de convolution pour extraire des informations à partir
de la matrice d'embedding. L'opération de convolution consiste à appliquer un noyau de convolution
de taille (h x e), où h est la taille de la fenêtre de convolution, sur la matrice d'embedding. Cette
opération produit une nouvelle matrice de taille ((n - h + 1) x c), où c est le nombre de canaux de
sortie.

4. Couche de pooling : La couche de pooling est souvent utilisée après la couche de convolution
pour réduire la dimensionnalité de la sortie et améliorer l'efficacité du modèle. Elle agrège
l'information extraite par la couche de convolution en prenant la valeur maximale, minimale
ou moyenne des caractéristiques détectées.

La couche de pooling réduit la taille de la matrice de sortie de la couche de convolution en agrégeant

les informations dans des régions spécifiques de la matrice. La méthode d'agrégation la plus courante
est la fonction max-pooling, qui extrait la valeur maximale dans chaque région de taille (p x c), où p
est la taille de la fenêtre de pooling.

5. Couche récurrente : La couche récurrente est utilisée pour capturer les dépendances
séquentielles dans le texte. Elle utilise une boucle de rétroaction pour mémoriser les
informations précédemment vues et les réutiliser lors du traitement de nouveaux éléments
de texte.

Les couches récurrentes sont basées sur des réseaux de neurones récurrents (RNN). Une cellule RNN
est une fonction mathématique qui prend une entrée et un état caché en entrée et renvoie une
sortie et un nouvel état caché en sortie. Les équations qui décrivent les opérations de la cellule RNN
sont les suivantes :

- h_t = f(x_t, h_{t-1})

- y_t = g(h_t)

où x_t est le vecteur d'embedding du mot à l'instant t, h_t est l'état caché à l'instant t, y_t est la
sortie à l'instant t, f est la fonction d'activation de la cellule RNN et g est la fonction de sortie de la
cellule RNN.

6. Couche d'attention : La couche d'attention est utilisée pour donner au modèle la capacité de
se concentrer sur des parties spécifiques du texte. Elle utilise des poids pour donner plus
d'importance aux parties du texte qui sont les plus pertinentes pour la tâche à accomplir.

La couche d'attention utilise des poids pour donner plus d'importance aux parties du texte qui sont
les plus pertinentes pour la tâche à accomplir. L'opération d'attention consiste à calculer un score
d'attention pour chaque mot de la séquence en utilisant un vecteur de poids de taille (e x 1), où e est
la dimension de l'espace vectoriel d'embedding. Les scores d'attention sont normalisés pour obtenir
des poids de somme égale à un, qui sont ensuite utilisés pour pondérer les vecteurs d'embedding de
la séquence et produire un vecteur d'embedding de contexte pondéré.

7. Couche de sortie : La couche de sortie est la dernière couche du modèle et produit la sortie finale.
Pour la classification de texte, la couche de sortie est souvent une couche entièrement connectée qui
prédit les étiquettes de sortie en fonction des caractéristiques extraites par les autres couches.

Chaque couche est optimisée de manière à minimiser l'erreur entre la sortie prédite et la sortie
réelle. Cela permet au modèle d'apprendre à partir des données d'entraînement et de produire des
prédictions précises sur de nouvelles données.

La couche de sortie prend le vecteur d'embedding de contexte pondéré et le transforme en une

prédiction de sortie. Pour une classification de

CNN Vs RNN en application

Les CNN (Convolutional Neural Networks) et les RNN (Recurrent Neural Networks) sont deux types
de réseaux de neurones qui sont souvent utilisés en NLP. Voici leurs principales utilisations et
différences :

Utilisations des CNN en NLP :

- Les CNN sont souvent utilisés pour la classification de texte et la modélisation de séquences de
mots.

- Ils peuvent être utilisés pour extraire des caractéristiques importantes à partir de séquences de
mots, comme les n-grammes et les relations entre les mots.

- Les CNN peuvent également être utilisés pour l'extraction de caractéristiques à partir d'images, de
sons et d'autres types de données non structurées.

Utilisations des RNN en NLP :

- Les RNN sont souvent utilisés pour la modélisation de séquences de mots, en raison de leur
capacité à prendre en compte le contexte précédent lors de la prédiction de la prochaine sortie.
- Ils peuvent être utilisés pour la génération de texte, la traduction automatique, la reconnaissance
vocale et d'autres tâches qui impliquent des séquences de données.

Différences entre les CNN et les RNN (Concepts et présentation mathématique) :

- Les CNN sont conçus pour l'analyse de données spatiales, comme les images, tandis que les RNN
sont conçus pour l'analyse de données séquentielles, comme le texte.

- Les CNN sont souvent utilisés pour l'extraction de caractéristiques à partir de données brutes,
tandis que les RNN sont souvent utilisés pour la modélisation de séquences de données.

- Les CNN sont des réseaux de neurones feedforward, ce qui signifie que l'information ne circule que
dans une direction. Les RNN, quant à eux, sont des réseaux de neurones récurrents, ce qui signifie
qu'ils peuvent prendre en compte l'information précédente lors de la prédiction de la prochaine
sortie.

- Les CNN sont plus efficaces pour la reconnaissance de motifs locaux, tandis que les RNN sont plus
efficaces pour la reconnaissance de motifs temporels et séquentiels.

Représentation mathématique de CNN et RNN

La représentation mathématique des CNN et des RNN implique l'utilisation de la notation matricielle
et vectorielle, ainsi que des fonctions d'activation non linéaires.

Représentation mathématique du CNN :

Un réseau de neurones convolutionnel (CNN) est composé de plusieurs couches de convolution, de

pooling et de couches entièrement connectées. La représentation mathématique d'une couche de
convolution peut être décrite comme suit :

Soit X une matrice d'entrée de taille m x n, K une matrice de filtre (kernel) de taille p x q et Y une
matrice de sortie de taille (m-p+1) x (n-q+1), alors la sortie Y peut être calculée comme suit :

Y = f(W * X + b)

Où W est une matrice de poids de taille p x q, b est un vecteur de biais, et f est une fonction
d'activation non linéaire telle que la fonction ReLU (Rectified Linear Unit) ou la fonction sigmoïde.

Représentation mathématique du RNN :

Un réseau de neurones récurrent (RNN) est conçu pour traiter des données séquentielles telles que
des phrases ou des séquences de temps. La représentation mathématique d'une couche de RNN
peut être décrite comme suit :

Soit X_t une entrée à l'instant t, H_t une sortie à l'instant t, H_t-1 une sortie à l'instant t-1, et W_xh,
W_hh et W_hy des matrices de poids, alors la sortie H_t peut être calculée comme suit :
H_t = f(W_xh * X_t + W_hh * H_t-1 + b)
Où b est un vecteur de biais et f est une fonction d'activation non linéaire telle que la fonction tanh
(tangente hyperbolique) ou la fonction ReLU (Rectified Linear Unit).

Dans les RNN, les sorties précédentes sont prises en compte lors du calcul de la sortie actuelle. Cette
propriété de récurrence permet au RNN de modéliser des séquences de données avec des
dépendances à long terme, ce qui est important pour de nombreuses tâches de NLP, telles que la
génération de texte et la traduction automatique.

Voici un exercice avec correction pour calculer la sortie d'un réseau CNN et d'un réseau RNN :

Remarque Mathématique :

La fonction sigmoïde est une fonction mathématique qui est couramment utilisée en apprentissage
automatique, en particulier dans les réseaux de neurones artificiels. Cette fonction a la forme d'une
courbe en S et est souvent utilisée pour modéliser des relations de probabilité entre des variables.

La fonction sigmoïde prend en entrée une valeur réelle et renvoie une valeur comprise entre 0 et 1.
La formule de la fonction sigmoïde est la suivante :

σ(x) = 1 / (1 + exp(-x))
où x est la valeur d'entrée, exp est la fonction exponentielle et σ(x) est la valeur de sortie.

La fonction sigmoïde est souvent utilisée pour transformer des valeurs continues en probabilités. Par
exemple, dans les réseaux de neurones, elle est utilisée pour modéliser les probabilités d'activation
ou de désactivation d'une unité de neurone. Elle peut également être utilisée pour modéliser des
probabilités dans des tâches de classification binaire.

Cependant, la fonction sigmoïde peut souffrir de certains problèmes, tels que la saturation des
gradients et la disparition des gradients, qui peuvent rendre l'apprentissage plus difficile. De nos
jours, d'autres fonctions d'activation telles que la fonction ReLU (Rectified Linear Unit) sont souvent
préférées en raison de leur simplicité et de leur efficacité.

Le produit de convolution est une opération mathématique couramment utilisée dans le traitement
du signal et les réseaux de neurones convolutifs (CNN). Le produit de convolution d'une fonction f(t)
et d'une fonction g(t) est défini comme suit :

(f * g)(t) = ∫f(τ)g(t-τ)dτ

où * est l'opérateur de convolution, t est le temps (ou l'indice de position pour les signaux discrets),
f(t) est la première fonction, g(t) est la deuxième fonction et ∫ représente l'intégration.

Le produit de convolution peut être vu comme une mesure de la similarité entre les deux fonctions
f(t) et g(t), décalées dans le temps. Pour chaque instant t, le produit de convolution évalue la zone de
recouvrement entre les deux fonctions après avoir effectué un retournement de g(t).

Dans les CNN, le produit de convolution est utilisé pour extraire des caractéristiques à partir de
données d'entrée, telles que des images ou des séquences de texte. Le produit de convolution est
appliqué à chaque zone de l'image ou de la séquence de texte, en utilisant des filtres appris par le
réseau pour extraire des caractéristiques spécifiques. Le résultat est une carte de caractéristiques qui
capture les motifs et les structures importants de l'entrée.

En résumé, le produit de convolution est une opération mathématique qui permet d'évaluer la
similarité entre deux fonctions décalées dans le temps, et qui est couramment utilisée dans le
traitement du signal et les réseaux de neurones convolutifs pour extraire des caractéristiques à partir
de données d'entrée.

Exercice :

Considérons un réseau de neurones convolutionnel (CNN) composé d'une couche de convolution

suivie d'une couche de pooling. La couche de convolution a une entrée X de taille (3x3x1) et un filtre
W de taille (2x2x1) avec un pas de 1 et un biais de 0. La couche de pooling a une fenêtre de 2x2 et un
pas de 2. La fonction d'activation utilisée est ReLU. Calculez la sortie du réseau.

Considérons maintenant un réseau de neurones récurrent (RNN) composé d'une couche de RNN
avec une cellule LSTM. La couche de RNN a une entrée X de taille (3x1) et une cellule de taille 2. Les
poids de la cellule LSTM sont initialisés avec les valeurs suivantes :

- W_f = [[-0.5, 0.4], [0.1, 0.2], [0.5, -0.2]]

- W_i = [[0.3, -0.2], [-0.4, 0.1], [0.2, -0.3]]

- W_c = [[0.2, 0.3], [-0.3, -0.1], [0.4, -0.5]]

- W_o = [[0.4, -0.5], [-0.2, 0.3], [0.1, 0.2]]

- U_f = [[0.1, 0.2], [0.3, -0.4]]

- U_i = [[0.2, -0.1], [-0.1, 0.3]]

- U_c = [[0.3, 0.2], [-0.2, -0.1]]

- U_o = [[-0.1, 0.2], [0.3, -0.2]]

- b_f = [0.1, 0.2]

- b_i = [0.3, -0.2]

- b_c = [-0.1, 0.4]

- b_o = [0.2, 0.1]

Calculez la sortie du réseau pour une entrée X=[1,2,3].

Correction :

Pour le réseau CNN :

La sortie de la couche de convolution peut être calculée comme suit :

Y = f(W * X + b) = ReLU([[-1, 0], [1, 4]] * [[1, 0, 1], [0, 2, 3], [2, 1, 0]] + [0]) = [[6, 10], [7, 10]]

La sortie de la couche de pooling peut être calculée comme suit :

Z = max_pool(Y) = [[6, 10]]

Par conséquent, la sortie du réseau CNN est Z = [[6, 10]].

Pour le réseau RNN :

Voici la suite de la correction de l'exercice précédent :

La première sortie de la cellule LSTM peut être calculée comme suit :

f_t = sigmoid(X_t * W_f + H_t-1 * U_f + b_f) = sigmoid([1, 2] * [[-0.5, 0.4], [0.1, 0.2], [0.5, -0.2]] + [0.1,
0.2] + [0, 0] * [[0.1, 0.2], [0.3, -0.4]]) = [0.9002, 0.7858]

i_t = sigmoid(X_t * W_i + H_t-1 * U_i + b_i) = sigmoid([1, 2] * [[0.3, -0.2], [-0.4, 0.1], [0.2, -0.3]] + [0.3,
-0.2] + [0, 0] * [[0.2, -0.1], [-0.1, 0.3]]) = [0.7311, 0.3087]

c_t = tanh(X_t * W_c + H_t-1 * U_c + b_c) = tanh([1, 2] * [[0.2, 0.3], [-0.3, -0.1], [0.4, -0.5]] + [-0.1,
0.4] + [0, 0] * [[0.3, 0.2], [-0.2, -0.1]]) = [0.9575, -0.9075]

o_t = sigmoid(X_t * W_o + H_t-1 * U_o + b_o) = sigmoid([1, 2] * [[0.4, -0.5], [-0.2, 0.3], [0.1, 0.2]] +
[0.2, 0.1] + [0, 0] * [[-0.1, 0.2], [0.3, -0.2]]) = [0.7710, 0.6135]

H_t = o_t * tanh(c_t) = [0.7445, -0.5575]

La sortie du réseau RNN pour l'entrée X=[1,2,3] est donc H_t = [0.7445, -0.5575].