Réseaux de neurones récurrents avec pytorch
nous allons implémenter un réseau neuronal récurrent qui effectue une analyse des sentiments.
nous utiliserons un ensemble de données de revues de films, accompagnées d’étiquettes de sentiment : positif ou négatif.
Architecture de réseau
dans notre solution, nous avons utilisé l’architecture suivante :
Tout d’abord, nous allons transmettre des mots à une couche d’embedding. Nous avons besoin d’une couche d’embedding parce que nous avons des dizaines de milliers de mots, d'où la nécessité d’une représentation plus efficace pour nos données d’entrée.
Une fois que les mots d’entrée sont passés dans une couche d’embedding, les nouvelles d’embedding sont transmises aux cellules LSTM.
Les cellules LSTM ajoutent des connexions récurrentes au réseau et nous donneront la possibilité d’inclure des informations sur la séquence des mots dans les données des revues de films.
Enfin, les sorties du LSTM iront vers une couche de sortie sigmoïde. Nous utilisons une fonction sigmoïde parce que on a deux étiquettes positif et négatif = 1 et 0, respectivement, et une sigmoïde produira des valeurs de sentiment prédites entre 0 et 1.
Chargement et visualisation des données
Prétraitement des données
La première étape de la construction d’un modèle de réseau neuronal consiste à mettre les données sous la forme appropriée. Puisque nous utilisons des couches d’embeddings , nous devons encoder chaque mot avec un entier.
Voici les étapes du traitement, que nous voudrons prendre :
- Nous voulons nous débarrasser des points et de la ponctuation inutiles.
- De plus, vous pouvez remarquer que les commentaires sont délimités par des caractères de nouvelle ligne \n. Pour gérer cela, on va diviser le texte de chaque revue en utilisant le caractère \n comme délimiteur.
- Ensuite, on peux combiner toutes les revues en une seule grande chaîne.
D’abord, enlevons toute la ponctuation. Ensuite, récupérons tout le texte sans les \n et divisons-le en mots individuels.
Codage des mots
la couche d’embedding nécessite que nous transmettions des entiers à notre réseau. La façon la plus simple de le faire est de créer des dictionnaires qui transforment les mots du vocabulaire en nombres entiers. Nous pouvons ensuite convertir chacune de nos revues en nombres entiers afin de les transmettre au réseau.
Codage des étiquettes
Nos étiquettes sont “positives” ou “négatives”. Pour utiliser ces étiquettes dans notre réseau, nous devons les convertir en 0 et 1.
Pour faire face aux revues courtes et très longues, nous allons compléter ou tronquer toutes nos revues à une longueur spécifique. Pour les commentaires les plus courts qu’une certaine seq_length, nous les remplissons de 0. Pour les commentaires plus longs que seq_length, nous pouvons les tronquer aux premiers mots de seq_length. Une bonne longueur de séquence, dans ce cas, est de 200.
Entraînement, validation, test
nous allons diviser nos données en ensembles de training, de validation et de test.
DataLoaders et Batching
Après avoir créé les données de training, test et validation, nous pouvons créer des DataLoaders pour nos données en suivant deux étapes :
- Créeons un format connu pour accéder à nos données, en utilisant TensorDataset qui prend un ensemble de données en entrée et un ensemble de données cible avec la même première dimension, et crée un ensemble de données.
- Créeons des DataLoaders et chargons nos ensembles de données Tensor de trainng, de validation et de test.
Réseau de sentiments avec PyTorch
Comme nous l’avons dit,nous allons utiliser le réseau suivant :
Les couches sont les suivantes :
- Une couche d’embeddings qui convertit nos revues (entiers) en embeddings d’une taille spécifique.
- Une couche LSTM définie par hidden_state et un nombre de couches.
- Une couche de sortie entièrement connectée qui associe les sorties de la couche LSTM à une taille de sortie souhaitée.
- Une couche d’activation sigmoïde qui transforme toutes les sorties en une valeur de 0 à 1
Instanciation du réseau
Ici, nous allons instancier le réseau. Tout d’abord, nous définissons les hyperparamètres.
.vocab_size : La taille de notre vocabulaire
. output_size:La taille de la sortie souhaitée,le nombre de scores de classe que nous voulons produire (pos/neg).
. embedding_dim: Le nombre de colonnes dans l’embeddings
. hidden_dim: Nombre d’unités dans les couches cachées de nos cellules LSTM
. n_layers: Nombre de couches LSTM dans le réseau. Généralement entre 1 et 3
Nous avons des hyparamètres de training
. lr: Learning rate de notre optimiseur
. epochs: Nombre de fois où il faut itérer l’ensemble de données de training.
. clip:pour éviter l’explosion des gradients
Il y a plusieurs façons de tester notre réseau :
- Test data performance : Tout d’abord, nous allons voir comment notre modèle entraîné se comporte sur l’ensemble de nos données de test définies ci-dessus. Nous allons calculer la loss moyenne et la précision sur les données de test.
- Inference on user-generated data : Ensuite, nous verrons si nous pouvons saisir un seul exemple de revue à la fois (sans étiquette), et voir ce que le modèle entraîné prédit.
Vous pouvez changer le test_review suivant en n’importe quel texte que vous voulez. Lisez-le et réfléchissez : est-ce positif ou négatif ? Puis voyez si notre modèle prédit correctement !
aprés le test on trouve que le revue définie est négatif, Maintenant que vous disposez d’un modèle entraîné et d’une fonction de prédiction, vous pouvez introduire n’importe quel type de texte et ce modèle prédit si le texte a un sentiment positif ou négatif.
Références
