Text Generation With LSTM Recurrent Neural Networks in Python with Keras

Université de Yaoundé 1 Departement informatique
Faculté de Sciences Master 1 Data Science

INF4248 : Aprentissage artificiel II

Fiche de TP n◦ 1

Noms	Prénoms	Matricule
CHIGNENG TCHITCHI	CHIROL	20U2763
KENMEGNE FOKAM	EMERIC CYRILLE	20U2897
WAFO TCHUELA	HARDIE STELLA	18T2825

importation des bibliotheques requises

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Dropout
from tensorflow.keras.layers import LSTM
from tensorflow.keras.callbacks import ModelCheckpoint
from tensorflow.keras.utils import to_categorical

Hidden output

Chargement du dataset avec la fonction open et l attribut read dans la variable raw_text et ensuite on vas mettre tout le texte en miniscules pour eviter les decomptent en plus des mots cet a dire 'PAPA' doit etre egal a 'papa' , il ne faudrais pas les differencier a cause du type de notation

# load ascii text and covert to lowercase
filename = "Wonderland.txt"
raw_text = open(filename, 'r', encoding='utf-8').read()
raw_text = raw_text.lower()

Ce bloc de code crée un mappage entre chaque caractère unique dans le texte et un entier unique. chars

D'abord,il extrait l'ensemble des caractères uniques présents dans raw_text en utilisant set(raw_text)
Ensuite il trie ces caractères dans l'ordre alphabétique avec sorted ce qui facilite la recherche et l'indexation ultérieures. chars devient alors une liste triée de tous les caractères uniques.
Après cela, il crée un dictionnaire char_to_int en utilisant une compréhension de dictionnaire. Pour chaque caractère dans chars, il l'associe à un indice (i), qui commence à 0 et augmente de 1 pour chaque caractère unique. Ce mappage est utile pour convertir le texte en une forme numérique que les modèles de machine learning peuvent traiter plus facilement.

# create mapping of unique chars to integers
chars = sorted(list(set(raw_text)))
char_to_int = dict((c, i) for i, c in enumerate(chars))

n_chars = len(raw_text)
n_vocab = len(chars)
print ("Total Characters: ", n_chars)
print ("Total Vocab: ", n_vocab)

Ce bloc de code prépare le jeu de données composé de paires entrée-sortie encodées en entiers pour l'entraînement d'un modèle de machine learning. Voici comment il fonctionne :

seq_length est défini à 100, ce qui signifie que chaque séquence d'entrée utilisée pour entraîner le modèle contiendra 100 caractères.
dataX et dataY sont initialisés comme des listes vides. dataX stockera les séquences d'entrée, et dataY stockera le caractère suivant dans le texte pour chaque séquence d'entrée, servant de sortie attendue pour le modèle.
La boucle for itère sur le texte brut (raw_text) en commençant de 0 jusqu'à n_chars - seq_length. n_chars est le nombre total de caractères dans le texte. Cette boucle permet de créer des séquences de longueur seq_length sans dépasser la fin du texte.
À chaque itération, une sous-chaîne de raw_text de longueur seq_length est extraite et stockée dans seq_in. Le caractère suivant immédiatement cette sous-chaîne est stocké dans seq_out.
seq_in est ensuite convertie en une liste d'entiers en utilisant le dictionnaire char_to_int pour trouver l'indice correspondant à chaque caractère. Cette liste est ajoutée à dataX.
De même, seq_out est converti en son indice entier correspondant et ajouté à dataY.
Après avoir parcouru tout le texte, n_patterns est calculé comme étant la longueur de dataX, ce qui représente le nombre total de séquences d'entrée (ou de motifs) générées.
Finalement, le nombre total de motifs est affiché, donnant une idée de la taille du jeu de données généré pour l'entraînement.

Ce processus est crucial pour transformer un texte brut en un format que les modèles de machine learning peuvent utiliser pour apprendre à prédire le caractère suivant dans une séquence, permettant la construction de modèles capables de générer du texte.

# prepare the dataset of input to output pairs encoded as integers
seq_length = 100
dataX = []
dataY = []
for i in range(0, n_chars - seq_length, 1):
 seq_in = raw_text[i:i + seq_length]
 seq_out = raw_text[i + seq_length]
 dataX.append([char_to_int[char] for char in seq_in])
 dataY.append(char_to_int[seq_out])
n_patterns = len(dataX)
print ("Total Patterns: ", n_patterns)

Ce bloc de code effectue plusieurs étapes de prétraitement sur les données pour les préparer à être utilisées dans un modèle de réseau de neurones récurrent (RNN).

Redimensionnement de X : La première ligne de code redimensionne le tableau dataX pour qu'il ait la forme [échantillons, pas de temps, caractéristiques]. Cela est nécessaire car les modèles de deep learning comme les RNN attendent les données d'entrée dans un format spécifique où chaque échantillon est un séquence temporelle de données. Dans ce cas, n_patterns représente le nombre total d'échantillons, seq_length le nombre de pas de temps dans chaque séquence, et 1 indique que chaque pas de temps est représenté par une seule caractéristique.
Normalisation : Ensuite, les données sont normalisées en divisant chaque élément par n_vocab, qui est le nombre total de caractères uniques dans le jeu de données. La normalisation est une étape courante de prétraitement des données qui aide à accélérer la convergence lors de l'entraînement de modèles de deep learning en s'assurant que toutes les caractéristiques sont sur une échelle similaire.
Encodage One-Hot de la variable de sortie : La dernière ligne de code transforme le tableau dataY en un format one-hot. Cela signifie que chaque élément de dataY est converti en un vecteur où un seul élément est égal à 1 et tous les autres éléments sont égaux à 0. La position de l'élément égal à 1 correspond à l'indice du caractère dans le vocabulaire. L'encodage one-hot est une méthode courante pour représenter des variables catégorielles dans des modèles de deep learning, car cela permet au modèle de traiter chaque catégorie comme étant indépendante des autres.

# reshape X to be [samples, time steps, features]
X = np.reshape(dataX, (n_patterns, seq_length, 1))
# normalize
X = X / float(n_vocab)
# one hot encode the output variable
y = to_categorical(dataY)

Ce bloc de code définit un modèle LSTM (Long Short-Term Memory) pour un problème de classification ou de prédiction de séquences en utilisant Keras.

Initialisation du modèle: Un modèle séquentiel est créé, ce qui signifie que les couches du réseau de neurones sont empilées l'une après l'autre.
Ajout d'une couche LSTM: La première couche ajoutée est une couche LSTM avec 256 unités. Cette couche prend en entrée des séquences dont la forme est spécifiée par input_shape=(X.shape[1], X.shape[2]), où X.shape[1] représente le nombre de pas de temps et X.shape[2] le nombre de caractéristiques par pas de temps.
Ajout d'une couche de Dropout: Une couche de Dropout est ajoutée ensuite pour réduire le surapprentissage. Ici, 20% des neurones sont ignorés aléatoirement pendant l'entraînement, ce qui aide à prévenir le surajustement.
Ajout d'une couche Dense: La dernière couche est une couche Dense (ou pleinement connectée) qui a un nombre d'unités égal au nombre de classes de sortie (déterminé par y.shape[1]). Cette couche utilise la fonction d'activation 'softmax' pour produire une distribution de probabilité sur les classes de sortie.
Compilation du modèle: Le modèle est compilé avec la fonction de perte 'categorical_crossentropy', et l'optimiseur 'adam'.

# define the LSTM model
model = Sequential()
model.add(LSTM(256, input_shape=(X.shape[1], X.shape[2])))
model.add(Dropout(0.2))
model.add(Dense(y.shape[1], activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam')

Ce bloc de code définit un point de contrôle (checkpoint) pour le modèle d'apprentissage profond en utilisant Keras. Voici une description détaillée de chaque ligne :

filepath="weights-improvement-{epoch:02d}-{loss:.4f}.keras" : Cette ligne définit le chemin du fichier où les poids du modèle seront sauvegardés. Le nom du fichier contiendra le numéro de l'époque (epoch) et la valeur de la fonction de perte (loss), avec une précision de 2 chiffres pour l'époque et 4 chiffres après la virgule pour la perte.
checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min') : Cette ligne crée un objet ModelCheckpoint qui est une sorte de rappel (callback) utilisé pour sauvegarder le modèle. Les paramètres spécifiés sont :
- filepath : le chemin du fichier où sauvegarder le modèle, défini précédemment.
- monitor='loss' : cela indique que le callback doit surveiller la valeur de la fonction de perte pour décider s'il faut sauvegarder le modèle.
- verbose=1 : cela active les messages de sortie détaillés, permettant de voir à chaque époque si le modèle a été sauvegardé.
- save_best_only=True : cela signifie que le modèle ne sera sauvegardé que si la valeur de la fonction de perte surveillée (loss) est la meilleure obtenue jusqu'à présent.
- mode='min' : cela indique que le but est de minimiser la valeur de la fonction de perte; donc, plus elle est basse, mieux c'est.
callbacks_list = [checkpoint] : Cette ligne crée une liste de callbacks contenant uniquement l'objet ModelCheckpoint défini précédemment.

‌
‌
‌

Text Generation With LSTM Recurrent Neural Networks in Python with Keras

.mfe-app-workspace-kj242g{position:absolute;top:-8px;}.mfe-app-workspace-11ezf91{display:inline-block;}.mfe-app-workspace-11ezf91:hover .Anchor__copyLink{visibility:visible;}INF4248 : Aprentissage artificiel II

Fiche de TP n◦ 1

importation des bibliotheques requises

INF4248 : Aprentissage artificiel II