Traitement du langage naturel (NLP)

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 :

  📋 Copy

  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.