Traitement du langage naturel (NLP)

Le traitement du langage naturel regroupe l’ensemble des méthodes permettant aux modèles d’intelligence artificielle de comprendre, analyser et générer du texte. L’objectif est de permettre aux machines d’interpréter le langage humain et d’interagir de manière cohérente avec celui-ci.

Le principe repose sur l’utilisation de techniques statistiques, de modèles neuronaux et de représentations vectorielles du texte. Les modèles modernes, comme les architectures transformer, apprennent à capter le contexte, les relations entre les mots et les structures grammaticales. Ces approches permettent d’effectuer des tâches variées telles que la classification de texte, la traduction, le résumé automatique, l’analyse de sentiment ou la génération de réponses.

Le NLP est utilisé dans les chatbots, la recherche d’information, l’assistance vocale, la modération de contenu, et tout domaine nécessitant l’analyse ou la production de langage écrit ou oral.

En résumé, le NLP permet aux modèles d’IA de comprendre et de manipuler le langage humain grâce à des représentations contextuelles et des architectures spécialisées.

Fonctions :

Traitement du langage naturel (exemple)

Le traitement du langage naturel (NLP) permet d’analyser, comprendre et générer du texte en langage humain grâce à des modèles d’apprentissage automatique. Cette technique est utilisée pour des tâches comme la classification de texte, l’analyse de sentiment, ou la génération automatique de texte.

Importation :

from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
import tensorflow as tf

Attributs :

Paramètre	Type	Description	Valeur par défaut
`texts`	list[str]	Liste des textes à analyser.	—
`max_length`	int	Longueur maximale des séquences de tokens.	`100`
`model`	tf.keras.Model	Modèle de deep learning entraîné pour la tâche NLP.	—

Exemple de code :

import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, GlobalAveragePooling1D, Dense

# Données d'exemple (phrases + labels binaires)
texts = [
    "J'adore le machine learning",
    "Je n'aime pas le spam"
]
labels = np.array([1, 0])  # 1 = positif, 0 = négatif

# Tokenization des textes
tokenizer = Tokenizer(num_words=1000)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)

# Padding pour uniformiser la longueur des séquences
padded = pad_sequences(sequences, maxlen=10, padding='post')

# Création du modèle simple
model = Sequential([
    Embedding(input_dim=1000, output_dim=16, input_length=10),
    GlobalAveragePooling1D(),
    Dense(16, activation='relu'),
    Dense(1, activation='sigmoid')
])

# Compilation du modèle
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Entraînement
model.fit(padded, labels, epochs=10, verbose=2)

# Prédiction sur de nouveaux exemples
test_texts = ["J'aime le deep learning", "Ce message est du spam"]
test_seq = tokenizer.texts_to_sequences(test_texts)
test_pad = pad_sequences(test_seq, maxlen=10, padding='post')
predictions = model.predict(test_pad)

for text, pred in zip(test_texts, predictions):
    print(f"Texte: {text} -> Probabilité positif: {pred[0]:.2f}")

Explication du code :

1. Importation des bibliothèques nécessaires

- Import de NumPy pour la gestion des tableaux numériques. - Import de TensorFlow et des modules Keras pour la tokenization, le padding, la création et l’entraînement du modèle.

2. Définition des données d'exemple

- Création d’une petite liste de phrases (`texts`) avec leurs labels binaires associés (`labels`), où 1 signifie une phrase positive et 0 une phrase négative.

3. Tokenization des textes

- Initialisation d’un tokenizer limité aux 1000 mots les plus fréquents. - Construction du vocabulaire à partir des textes. - Conversion des phrases en séquences d’entiers, chaque entier représentant un mot.

4. Padding des séquences

- Uniformisation de la longueur des séquences à 10 tokens maximum en ajoutant des zéros à la fin des séquences plus courtes (`padding='post'`).

5. Création du modèle séquentiel

- Couche `Embedding` pour transformer chaque mot (index) en un vecteur dense de dimension 16, avec une séquence d’entrée de longueur 10. - Couche `GlobalAveragePooling1D` qui calcule la moyenne sur la dimension temporelle, résumant la séquence en un vecteur fixe. - Couche dense de 16 neurones avec activation ReLU pour apprendre des représentations complexes. - Couche de sortie dense avec un neurone et activation sigmoïde pour produire une probabilité entre 0 et 1 (classification binaire).

6. Compilation du modèle

- Optimiseur Adam pour la mise à jour efficace des poids. - Fonction de perte `binary_crossentropy` adaptée à la classification binaire. - Évaluation via la métrique `accuracy` (précision).

7. Entraînement du modèle

- Entraînement du modèle sur les séquences préparées et leurs labels pendant 10 epochs. - Affichage détaillé de la progression de l’entraînement.

8. Prédictions sur de nouveaux exemples

- Préparation des nouvelles phrases en séquences et padding identiques aux données d’entraînement. - Prédiction des probabilités d’appartenance à la classe positive. - Affichage des phrases test avec leur probabilité de positif.