![Comment utiliser les techniques et outils de NLP dans vos projets [Guide complet]](https://cdn.hashnode.com/res/hashnode/image/upload/v1763743424066/393a4384-ce7a-4ff8-9e98-1edaaa322bc6.png)
Article original : How to Use NLP Techniques and Tools in Your Projects [Full Handbook]
De nos jours, les ordinateurs peuvent comprendre et produire un langage semblable à celui des humains grâce au Traitement du Langage Naturel (NLP). Cela ouvre de nombreuses opportunités pour vous en tant que développeur.
Ce guide vous apprendra comment créer des projets de NLP à partir de zéro. Il comprend des détails sur la manière d'organiser votre workflow, d'utiliser les outils appropriés et d'effectuer les tâches de NLP typiques.
Après avoir lu cet article, vous comprendrez comment :
Configurer votre environnement pour le développement NLP.
Sélectionner les Frameworks et bibliothèques appropriés pour votre projet.
Exécuter des tâches fondamentales de NLP telles que l'analyse de sentiment et la classification de texte.
Créer et implémenter une application NLP fonctionnelle.
Diagnostiquer et corriger les problèmes courants dans les projets NLP.
Avant de commencer, vous devriez déjà avoir quelques bases. Elles incluent une solide compréhension de la programmation Python et une connaissance des idées générales du Machine Learning. Vous devriez également savoir comment construire des algorithmes et des structures de données. Enfin, votre système doit avoir Python 3.8 ou supérieur installé pour pouvoir tester les extraits de code d'exemple.
Table des matières
Qu'est-ce que le Traitement du Langage Naturel (NLP) ?
Le NLP (Natural Language Processing) est un ensemble de méthodologies qui permettent aux ordinateurs d'apprendre à comprendre le langage humain et à produire des résultats pertinents.
Le NLP gère la complexité de la communication humaine. Contrairement au Machine Learning conventionnel, qui ne fonctionne qu'avec des données structurées, le NLP traite des données textuelles non structurées.
Plus précisément, pour comprendre le langage avec plus de précision, les systèmes de NLP analysent simultanément la syntaxe (l'agencement des mots et la grammaire), la sémantique (le sens des mots et des phrases spécifiques) et interprètent le contexte (comment les informations adjacentes affectent le sens). Cela leur permet de différencier les diverses interprétations de mots identiques, de saisir les messages implicites et de produire des réponses aussi pertinentes que possible.
La capacité des machines à traiter le langage a été démontrée par des expériences précoces telles que la traduction Georgetown-IBM en 1954 et le chatbot ELIZA en 1966 (Sources : Szmurlo and Akhtar, MDPI; Hutchins, ResearchGate). Avec les outils d'aujourd'hui, n'importe quel développeur peut accéder aux capacités des outils de NLP et les utiliser.
Alors pourquoi est-ce important pour vous ? En 2025, le marché du NLP, qui alimente actuellement les chatbots, les logiciels de traduction et les plateformes de création de contenu, a atteint 42,47 milliards de dollars. (Source : Precedence Research)
La croissance ne fait que s'accélérer. D'ici 2030, le marché mondial du NLP devrait atteindre 439,85 milliards de dollars. (Source : GrandviewResearch).
Concepts importants de NLP à connaître
Cinq couches interconnectées composent généralement les systèmes de NLP. Chaque couche traite un problème distinct de traitement du langage. (Source : Khatri and others, ResearchGate).
L'analyse morphologique est l'étape où vous décomposez les mots en leurs composants les plus significatifs. Les mots seront décomposés en préfixes, racines et suffixes. Par exemple, "working" devient "work" plus "ing". Cela permet à votre système de mieux comprendre les relations entre les mots, même lorsqu'ils changent de forme.
L'analyse de la structure syntaxique consiste à utiliser des règles de grammaire pour déterminer la structure de la phrase. Ici, vous construisez des arbres syntaxiques (parse trees) qui cartographient les relations grammaticales entre les mots. Les mots individuels sont représentés comme des feuilles, les syntagmes comme des nœuds intermédiaires et les phrases comme des racines dans l'arbre.
L'analyse sémantique est l'étape où, à partir de la structure analysée, vous dérivez le sens réel.
Vous traitez les synonymes, les antonymes et les homophones ainsi que l'ambiguïté des mots. Cela transforme la structure grammaticale en signification.
L'analyse du discours consiste à connecter les phrases au sein de structures textuelles plus longues. Vous observerez comment les idées circulent d'un paragraphe à l'autre et repérerez les thèmes récurrents. Cela relie le sens au niveau de la phrase au sens au niveau du document.
L'analyse pragmatique est l'étape où vous déchiffrez l'intention et le contexte. Vous serez en mesure de résoudre les références, de comprendre la structure du dialogue et de déchiffrer les significations implicites. Vous pouvez traiter le sarcasme, le contexte culturel et d'autres aspects de la communication quotidienne à cette couche.
Comprendre ces couches vous donne la capacité de construire des systèmes de NLP capables de gérer des tâches linguistiques complexes dans divers contextes.
Comment les systèmes de NLP interprètent la parole
Les systèmes de NLP utilisent un pipeline pour convertir le texte brut en signification computationnelle. Chaque étape s'appuie sur la précédente, permettant une meilleure analyse des données linguistiques non structurées. Dans cette section, je vais fournir de réels extraits de code que vous pouvez insérer dans un éditeur pour l'entraînement.
Étape 1 : Entrée du texte
Pour commencer, votre système recevra du texte brut qui peut se présenter sous diverses formes. Les sources potentielles d'entrée brute incluent les e-mails, les publications sur les réseaux sociaux, les articles, les documents ou les transcriptions de discours. Les données brutes contiendront des fautes d'orthographe, un langage familier et des erreurs grammaticales que vous devrez contourner.
Étape 2 : Prétraitement du texte
Ensuite, vous devrez nettoyer et standardiser le texte d'entrée avant que votre système ne l'analyse. Votre prétraitement inclura probablement tout ou partie de ces étapes :
Tokenisation du texte en mots simples ou sous-mots
Suppression des signes de ponctuation du texte
Mise en minuscules de tout le texte
Suppression des mots vides (stop words) comme "the", "and" et "is".
Par exemple, vous pouvez accomplir une forme aussi simple de NLP en utilisant Python, mais notez que vous devez importer des bibliothèques spécifiques (nous en discuterons plus tard) :
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
# Download required NLTK data
nltk.download('punkt')
nltk.download('stopwords')
# Raw text input
text = "The quick brown fox jumps over the lazy dog!"
# Tokenization
tokens = word_tokenize(text.lower())
# Remove punctuation and stop words
stop_words = set(stopwords.words('english'))
filtered_tokens = [word for word in tokens if word.isalnum() and word not in stop_words]
print(filtered_tokens)
# Output: ['quick', 'brown', 'fox', 'jumps', 'lazy', 'dog']
Étape 3 : Analyse syntaxique et parsing
Après le nettoyage, vous analyserez la structure grammaticale du texte en construisant des arbres syntaxiques. Bien que les arbres syntaxiques puissent varier en complexité, ils cartographient les relations entre les mots, les syntagmes et les propositions. Vous pouvez exploiter les informations d'étiquetage morphosyntaxique (part-of-speech tagging) pour assigner des rôles grammaticaux (nom, verbe, adjectif, etc.) aux mots, et le parsing de dépendances pour apprendre comment les mots liés sont connectés syntaxiquement.
Par exemple, le code ci-dessous illustre comment effectuer un étiquetage morphosyntaxique avec spaCy, qui détermine la fonction grammaticale de chaque mot au sein d'une phrase.
import spacy
# Load English language model
nlp = spacy.load("en_core_web_sm")
# Process text
doc = nlp("The cat sat on the mat")
# Part-of-speech tagging
for token in doc:
print(f"{token.text}: {token.pos_}")
# Output:
# The: DET
# cat: NOUN
# sat: VERB
# on: ADP
# the: DET
# mat: NOUN
Étape 4 : Ingénierie des caractéristiques et représentation du texte
Ici, vous convertissez les mots en vecteurs numériques que les ordinateurs peuvent analyser en utilisant des techniques d'Embedding ou basées sur les Transformers pour capturer les similitudes et les relations sémantiques entre les termes. Par exemple, cela permet à votre système de comprendre que les mots "kid" et "child" ont un sens similaire.
from sentence_transformers import SentenceTransformer
# Load pre-trained model
model = SentenceTransformer('all-MiniLM-L6-v2')
# Convert sentences to embeddings
sentences = ["The cat sits on the mat", "The feline rests on the rug"]
embeddings = model.encode(sentences)
print(f"Embedding shape: {embeddings.shape}")
# Output: Embedding shape: (2, 384)
Étape 5 : Modélisation et reconnaissance de motifs
Dans cette partie du processus, vous utiliserez des algorithmes de Machine Learning pour identifier des motifs à partir du texte vectorisé. Vous pouvez utiliser soit une représentation de Machine Learning traditionnelle, soit l'une des méthodes de Deep Learning, telles que les Transformers. Vos modèles apprendront les motifs du langage, classeront le contenu présenté ou extrairont des entités dans le texte.
Pour comprendre cette méthode, voyons un exemple simple d'un modèle de classification de texte qui utilise des Transformers pour identifier les sentiments.
from transformers import pipeline
# Load a pre-trained sentiment analysis model
classifier = pipeline("sentiment-analysis")
# Classify text sentiment
texts = ["I love this product!", "This is terrible and disappointing"]
results = classifier(texts)
for text, result in zip(texts, results):
print(f"Text: {text}")
print(f"Sentiment: {result['label']}, Confidence: {result['score']:.2f}\n")
# Output:
# Text: I love this product!
# Sentiment: POSITIVE, Confidence: 0.99
#
# Text: This is terrible and disappointing
# Sentiment: NEGATIVE, Confidence: 0.99
Ceci illustre comment le modèle détecte des motifs linguistiques pour la catégorisation des sentiments, ce qui est une tâche typique en NLP. Dans les sections suivantes, nous approfondirons des techniques de modélisation plus spécialisées adaptées à diverses applications NLP.
Étape 6 : Évaluation et déploiement
Ensuite, vous évaluerez votre modèle à partir de métriques telles que la précision, le rappel et les scores F1. Après l'évaluation, vous déploierez votre modèle en production, et le modèle continuera d'apprendre à partir des données produites par le texte du monde réel. Voici un exemple de la façon dont cela est fait :
from sklearn.metrics import classification_report
# Example predictions vs actual labels
y_true = [0, 1, 1, 0, 1]
y_pred = [0, 1, 0, 0, 1]
# Generate evaluation metrics
print(classification_report(y_true, y_pred))
Tâches courantes en NLP
Tâches de compréhension du langage naturel (NLU)
Les tâches de compréhension du langage naturel (NLU) consistent à comprendre réellement ce que les gens communiquent. Plusieurs éléments sont impliqués dans ce processus.
Analyse de sentiment et classification de texte
Ici, vous reconnaissez et catégorisez les documents selon l'émotion. Votre moteur identifie si le texte transmet un sentiment positif, négatif ou neutre. Ensuite, il filtre de manière autonome le contenu sur les plateformes numériques. Considérez cet exemple :
from transformers import pipeline
# Load sentiment analysis pipeline
classifier = pipeline("sentiment-analysis")
# Analyze sentiment
result = classifier("I love this product! It works great.")
print(result)
# Output: [{'label': 'POSITIVE', 'score': 0.9998}]
Reconnaissance d'entités nommées (NER)
Le NER est un pipeline qui consiste à identifier et classer automatiquement des éléments d'information distincts au sein d'un corps de texte. Cela inclut les noms de personnes, les lieux, les organisations, les dates et les chiffres monétaires.
Votre système NER analyse le texte non structuré pour étiqueter avec précision ces entités, convertissant les données brutes en un format structuré qui peut être facilement analysé. Votre algorithme peut également découvrir des relations entre ces entités, vous permettant d'obtenir des informations précieuses à partir de quantités massives de texte.
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("Apple Inc. was founded by Steve Jobs in Cupertino, California.")
for ent in doc.ents:
print(f"{ent.text}: {ent.label_}")
# Output:
# Apple Inc.: ORG
# Steve Jobs: PERSON
# Cupertino: GPE
# California: GPE
Questions-réponses
Vous pouvez créer des systèmes qui consomment des questions en langage naturel et récupèrent les réponses appropriées. Votre système peut également utiliser la détection d'implication et de contradiction pour analyser les relations logiques entre les blocs de texte.
Reconnaissance d'intention
Vous pouvez reconnaître les intentions des utilisateurs dans des domaines conversationnels. Vos systèmes de dialogue sont conscients des objectifs de l'utilisateur, permettant aux boutons ou aux voix de répondre en conséquence.
Passons maintenant à quelques tâches générales liées au langage naturel.
Tâches générales de langage naturel
Cette classe de tâches regroupe certains aspects de la compréhension tout en traitant également de la génération.
Traduction automatique
Vous pouvez traduire du texte dans plusieurs langues tout en préservant le contexte et le sens. Les réseaux de neurones utilisent des architectures encodeur-décodeur pour créer des sorties linguistiques dans la langue cible.
Voyons comment cela est fait avec les modèles MarianMTModel et MarianTokenizer :
from transformers import MarianMTModel, MarianTokenizer
# Load translation model
model_name = 'Helsinki-NLP/opus-mt-en-es'
tokenizer = MarianTokenizer.from_pretrained(model_name)
model = MarianMTModel.from_pretrained(model_name)
# Translate English to German
text = "Hello, how are you?"
translated = model.generate(**tokenizer(text, return_tensors="pt", padding=True))
print(tokenizer.decode(translated[0], skip_special_tokens=True))
# Output: Hallo, wie geht's dir?
Résumé de texte
Souvent, vous aurez besoin de raccourcir un long document en un résumé plus accessible – c'est le résumé de texte, et c'est une tâche courante en NLP. Votre système conserve les détails clés et la cohérence tout en réduisant la longueur d'un document.
Reconnaissance vocale et synthèse vocale (Text-to-Speech)
En utilisant ces techniques, vous pouvez transformer la parole en texte (reconnaissance vocale) ou le texte en audio naturel (synthèse vocale). Ces tâches comblent le fossé entre les modalités textuelles et audio.
Analyse syntaxique (Parsing)
Ici, vous examinez la construction grammaticale pour déterminer les relations syntaxiques entre les mots de la phrase. Cette tâche critique fournit une analyse structurelle du texte pour soutenir des tâches de compréhension plus complexes.
Ces tâches, lorsqu'elles sont combinées, créent des applications puissantes pour différentes industries et cas d'utilisation dans le Traitement du Langage Naturel.
Méthodes classiques de Machine Learning pour le NLP
Au lieu de s'appuyer sur des règles linguistiques créées manuellement (où les programmeurs spécifient des motifs comme "si un mot se termine par '-ing', il s'agit probablement d'un verbe" ou "les phrases contenant 'not' suivi de mots positifs suggèrent un sentiment négatif"), les approches de ML appliquent des méthodes statistiques pour découvrir automatiquement des motifs au sein des données.
Ces méthodes apprennent par l'exemple et ne nécessitent pas d'experts humains pour définir explicitement chaque structure de langage potentielle. En conséquence, elles sont plus évolutives et adaptables à travers différentes langues et domaines. Examinons-en quelques-unes maintenant.
Régression logistique
Pour les tâches impliquant une classification binaire, vous pouvez utiliser la régression logistique. Basée sur les caractéristiques d'entrée, elle prédit la probabilité d'un événement en apprenant des frontières de décision linéaires. Considérez l'exemple suivant :
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
# Sample data
texts = ["This is spam", "Normal email", "Buy now!", "Meeting tomorrow"]
labels = [1, 0, 1, 0] # 1 = spam, 0 = not spam
# Convert text to features
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(texts)
# Train model
X_train, X_test, y_train, y_test = train_test_split(X, labels, test_size=0.25)
model = LogisticRegression()
model.fit(X_train, y_train)
# Predict
new_text = vectorizer.transform(["Free money now"])
prediction = model.predict(new_text)
print(f"Prediction: {'Spam' if prediction[0] == 1 else 'Not Spam'}")
Les utilisations typiques incluent la classification de la toxicité, l'analyse de sentiment et la détection de spam.
Naive Bayes
En utilisant le principe selon lequel les mots sont indépendants, Naive Bayes applique le Théorème de Bayes.
Pour classer les documents, il calcule :
$$P(label|text) = P(label) × P(text|label) / P(text)$$
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer
# Training data
texts = ["I love this product", "Terrible service", "Amazing quality", "Waste of money"]
labels = [1, 0, 1, 0] # 1 = positive, 0 = negative
# Vectorize text
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(texts)
# Train Naive Bayes
clf = MultinomialNB()
clf.fit(X, labels)
# Predict sentiment
new_review = vectorizer.transform(["Great purchase"])
print(f"Sentiment: {'Positive' if clf.predict(new_review)[0] == 1 else 'Negative'}")
Les utilisations courantes de cet algorithme que vous pouvez essayer sont la détection de spam et la détection de bugs dans les logiciels.
Arbres de décision
Les arbres de décision partitionnent les ensembles de données de manière récursive en choisissant la caractéristique qui maximise le gain d'information à chaque division, de manière à construire des modèles interprétables en forme d'arbre. Chaque nœud interne est une décision (sur une caractéristique), chaque branche est un résultat de la décision, et chaque nœud feuille est une classification.
Les arbres de décision sont particulièrement utiles pour la classification de texte et la sélection de caractéristiques car l'arbre de décision vous permet de tracer exactement comment le modèle a pris la décision de classification prédite.
Voyons un exemple de code qui montre comment l'arbre de décision apprend quels mots, convertis en caractéristiques TF-IDF, prédisent si le sentiment du texte en question est positif ou négatif :
from sklearn.tree import DecisionTreeClassifier
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
# Sample text data with labels
texts = [
"I love this movie, it's fantastic",
"Terrible film, waste of time",
"Amazing performance and great story",
"Boring and disappointing",
"Excellent cinematography and acting",
"Awful, would not recommend"
]
labels = [1, 0, 1, 0, 1, 0] # 1 = positive, 0 = negative
# Convert text to TF-IDF features
vectorizer = TfidfVectorizer(max_features=20)
X = vectorizer.fit_transform(texts)
# Split data
X_train, X_test, y_train, y_test = train_test_split(X, labels, test_size=0.3, random_state=42)
# Train decision tree
clf = DecisionTreeClassifier(max_depth=3, random_state=42)
clf.fit(X_train, y_train)
# Make predictions
test_text = ["This movie is wonderful"]
test_vector = vectorizer.transform(test_text)
prediction = clf.predict(test_vector)
print(f"Text: {test_text[0]}")
print(f"Predicted sentiment: {'Positive' if prediction[0] == 1 else 'Negative'}")
print(f"Model accuracy: {clf.score(X_test, y_test):.2f}")
À chaque nœud, l'arbre de décision pose une question : "Le texte a-t-il un score TF-IDF élevé pour 'wonderful' ?" Ensuite, l'arbre bifurquera en conséquence en fonction de la réponse à la question jusqu'à atteindre une classification.
Un paramètre clé dans le code ci-dessus est max_depth=3 – sans lui, l'arbre pourrait devenir trop complexe et faire du surapprentissage (overfitting). Le paramètre limite la complexité de l'arbre.
Allocation de Dirichlet latente (LDA)
L'Allocation de Dirichlet latente (LDA) détermine automatiquement les structures thématiques dans de grandes collections de textes en traitant les documents comme des mélanges probabilistes de sujets, et les sujets comme des distributions sur les mots. Cette approche de découverte utilise l'apprentissage non supervisé, ce qui signifie qu'aucune donnée d'entraînement étiquetée n'est nécessaire pour découvrir des thèmes structurés mais cachés. La LDA est adaptée à l'analyse exploratoire de texte et à l'organisation de données dans des quantités importantes de texte.
Voyons un code qui génère une matrice de fréquence de mots à partir de documents. Dans ce code, la LDA identifie deux sujets sous-jacents basés sur les motifs de cooccurrence de mots, un processus qui est un type d'analyse de clustering pour les documents textuels.
from sklearn.decomposition import LatentDirichletAllocation
from sklearn.feature_extraction.text import CountVectorizer
# Document collection
documents = [
"Machine learning algorithms process data",
"Deep learning uses neural networks",
"Python is great for data science",
"Neural networks learn from examples"
]
# Create document-term matrix
vectorizer = CountVectorizer(max_features=50)
doc_term_matrix = vectorizer.fit_transform(documents)
# Train LDA model
lda = LatentDirichletAllocation(n_components=2, random_state=42)
lda.fit(doc_term_matrix)
# Display topics
feature_names = vectorizer.get_feature_names_out()
for topic_idx, topic in enumerate(lda.components_):
top_words_idx = topic.argsort()[-5:]
top_words = [feature_names[i] for i in top_words_idx]
print(f"Topic {topic_idx}: {', '.join(top_words)}")
Dans cette illustration, nous pourrions interpréter le Sujet 0 comme "science des données et algorithmes" et le Sujet 1 comme "réseaux de neurones et Deep Learning". Le modèle LDA assignera, selon un modèle mixte, une distribution de probabilité pour chaque document tombant sous les deux sujets. Par exemple, un document intitulé "réseaux de neurones pour le traitement des données" pourrait être considéré comme étant à 60 % du Sujet 1 et à 40 % du Sujet 0.
Modèles de Deep Learning
Les modèles de Deep Learning extraient automatiquement des représentations hiérarchiques à partir du texte brut sans ingénierie manuelle des caractéristiques. L'application du Deep Learning au traitement du langage est importante car la compréhension du langage nécessite de modéliser non seulement les mots individuels, mais aussi les syntagmes, les phrases et le contexte dans son ensemble.
Une architecture neuronale parvient à cette modélisation en apprenant plusieurs couches d'abstraction et peut interpréter les phrases de manières plus complexes, telles que le sentiment, l'intention ou le sujet.
Illustrons comment cela fonctionne avec un exemple montrant un modèle de Deep Learning simplifié qui peut être utilisé pour la classification de texte à l'aide de TensorFlow/Keras. Cet exemple spécifique utilise une couche d'Embedding pour mapper les mots à des vecteurs denses qui capturent leur sens sémantique, ainsi qu'une couche LSTM bidirectionnelle capable de capturer des informations du passé et du futur d'une séquence et de les transmettre à une couche Dense pour la classification binaire.
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
# Example sentences and labels
texts = ["I like this movie", "I hate this movie"]
labels = [1, 0] # 1 = positive, 0 = negative
# Tokenize text and pad sequences
tokenizer = Tokenizer(num_words=50)
tokenizer.fit_on_texts(texts)
X = pad_sequences(tokenizer.texts_to_sequences(texts), maxlen=5)
# Simple model: embedding + LSTM + output
model = Sequential([
Embedding(input_dim=50, output_dim=8, input_length=5),
LSTM(4),
Dense(1, activation='sigmoid')
])
model.compile(optimizer='adam', loss='binary_crossentropy')
model.fit(X, labels, epochs=5, verbose=0)
# Predict sentiment for new sentence
test_text = ["I love this"]
test_seq = pad_sequences(tokenizer.texts_to_sequences(test_text), maxlen=5)
pred = model.predict(test_seq)[0][0]
print(f"Sentiment score: {pred:.2f} (1=positive, 0=negative)")
Le modèle apprend ces motifs à partir de phrases d'exemple qui ont été étiquetées comme positives ou négatives, puis utilise ces motifs appris pour prédire le sentiment d'une nouvelle entrée textuelle. C'est un exemple de la façon dont les modèles de Deep Learning apprennent à représenter automatiquement le texte traité, puis utilisent cette représentation pour interpréter des séquences de texte à des fins de classification, sans aucune ingénierie de caractéristiques.
Réseaux de neurones convolutifs (CNN)
Les CNN appliquent au texte le même cadre de détection de motifs qu'ils utilisent pour la reconnaissance d'images. Les CNN voient les documents comme des séquences, et lorsqu'un filtre convolutif est appliqué sur le texte, il détecte des motifs pour divers types de caractéristiques, tels que les n-grammes (séquences de symboles adjacents) et les syntagmes significatifs.
Les CNN englobent des couches multi-filtres pour détecter différentes caractéristiques. Chaque couche de filtre détecte des caractéristiques de plus en plus abstraites, allant de simples combinaisons de mots à la capture de combinaisons de mots systématiquement utilisées dans des motifs sémantiques, créant une utilisation efficace pour la tâche de classification de texte. (Source : Yoon Kim)
Voici un exemple de la couche convolutive balayant le texte à l'aide de filtres. Elle détecte des motifs significatifs établis par un apprentissage préalable, tels que le mot "excellent" ou "terrible waste", apprenant à traiter chaque combinaison de mots comme exprimant un sentiment positif ou négatif lors d'une étape finale de classification.
import tensorflow as tf
from tensorflow.keras.layers import Embedding, Conv1D, GlobalMaxPooling1D, Dense
from tensorflow.keras.models import Sequential
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
# Sample training data
texts = [
"This movie is excellent and entertaining",
"Terrible film, complete waste",
"Amazing story and great acting",
"Boring and poorly made"
]
labels = [1, 0, 1, 0] # 1 = positive, 0 = negative
# Tokenize and pad sequences
tokenizer = Tokenizer(num_words=100)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
X = pad_sequences(sequences, maxlen=10)
# Build CNN model
model = Sequential([
Embedding(input_dim=100, output_dim=32, input_length=10), # Convert words to dense vectors
Conv1D(filters=64, kernel_size=3, activation='relu'), # Detect 3-word patterns
GlobalMaxPooling1D(), # Extract most important features
Dense(1, activation='sigmoid') # Binary classification
])
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
model.fit(X, labels, epochs=10, verbose=0)
# Test prediction
test_text = ["wonderful movie with great plot"]
test_seq = tokenizer.texts_to_sequences(test_text)
test_pad = pad_sequences(test_seq, maxlen=10)
prediction = model.predict(test_pad)
print(f"Sentiment probability: {prediction[0][0]:.2f}")
print(f"Classification: {'Positive' if prediction[0][0] > 0.5 else 'Negative'}")
La couche de pooling analyse ce texte filtré et fait ressortir les signaux les plus substantiels pour mesurer les sentiments positifs par rapport aux sentiments négatifs à partir des caractéristiques textuelles convolutives des étapes précédentes.
Réseaux de neurones récurrents (RNN)
Les RNN gèrent les données séquentielles en suivant des états cachés qui reflètent les dépendances au fil du temps. À chaque étape temporelle, le RNN reçoit le mot actuel et l'état caché précédent comme entrée et modifie l'état caché, ce qui reflète le contexte accumulé.
Voici un exemple concret où, à mesure que le RNN lit le mot suivant de gauche à droite, il met à jour son état caché pour maintenir le contexte.
import tensorflow as tf
from tensorflow.keras.layers import Embedding, SimpleRNN, Dense
from tensorflow.keras.models import Sequential
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
# Training data
texts = [
"I really enjoyed this book",
"The plot was confusing and dull",
"Fantastic read, highly recommend",
"Disappointing and poorly written"
]
labels = [1, 0, 1, 0]
# Prepare data
tokenizer = Tokenizer(num_words=100)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
X = pad_sequences(sequences, maxlen=10)
# Build RNN model
model = Sequential([
Embedding(input_dim=100, output_dim=32, input_length=10),
SimpleRNN(units=64, return_sequences=False), # Process sequence and maintain hidden state
Dense(1, activation='sigmoid')
])
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
model.fit(X, labels, epochs=20, verbose=0)
# Test
test_text = ["amazing story highly engaging"]
test_seq = tokenizer.texts_to_sequences(test_text)
test_pad = pad_sequences(test_seq, maxlen=10)
prediction = model.predict(test_pad)
print(f"Sentiment probability: {prediction[0][0]:.2f}")
Les phrases plus longues sont plus complexes car l'information contenue dans l'état caché se perd sur un nombre croissant d'étapes temporelles. C'est la motivation pour les architectures plus sophistiquées de mémoire à long et court terme (LSTM) et d'unité récurrente à porte (GRU).
Architectures Encodeur-Décodeur
Ces architectures comportent deux réseaux de neurones qui travaillent ensemble. Le premier réseau de neurones encodeur prend le texte d'entrée et le réduit à une représentation dense de taille fixe mais encode le sens essentiel. Ensuite, un second réseau décodeur génère un texte de sortie basé sur la représentation du sens.
Ces architectures apprennent une représentation compressée des données d'entrée, et elles sont souvent utilisées pour :
Les réductions de dimensionnalité.
L'apprentissage de caractéristiques.
Le clustering de documents.
Les tâches de séquence à séquence (par exemple, les traductions ou les résumés).
L'exemple suivant illustre comment utiliser un modèle encodeur-décodeur Text-to-Text Transfer Transformer (T5) pour traduire l'anglais en allemand. L'encodeur prend la phrase anglaise d'entrée et construit sa représentation interne du texte, tandis que le décodeur génère la traduction allemande basée sur cette représentation :
from transformers import T5Tokenizer, T5ForConditionalGeneration
# Load T5 model for text generation
tokenizer = T5Tokenizer.from_pretrained("t5-small")
model = T5ForConditionalGeneration.from_pretrained("t5-small")
# Translate text
input_text = "translate English to German: Hello, how are you?"
input_ids = tokenizer(input_text, return_tensors="pt").input_ids
# Generate translation
outputs = model.generate(input_ids)
translation = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"Translation: {translation}")
Cette architecture résout le problème de la longueur variable des entrées et des sorties de manière très élégante. Le réseau de neurones d'encodage réduit la phrase à une représentation de taille fixe quelle que soit la longueur de l'entrée. Par la suite, le décodeur génère une sortie pour la longueur qu'il juge appropriée en fonction de la longueur de l'entrée, qu'il s'agisse d'une phrase ou de six phrases.
Modèles Transformers
Contrairement aux RNN, dans lesquels le texte est traité séquentiellement (un mot à la fois), les Transformers utilisent un mécanisme de traitement qui évalue la séquence en parallèle. Cela signifie que le Transformer peut considérer simultanément tous les mots d'une phrase et calculer directement les relations entre n'importe quels deux mots, même éloignés.
Dans l'exemple ci-dessous, "The girl didn't go to school because she was ill," le modèle connecte directement "she" avec "girl" malgré les autres mots entre les deux. Cela apporte une capacité plus rapide d'entraînement sur l'information et aide à éviter la dégradation de l'information au fil des étapes temporelles. (Source : Vaswani and others).
Dans l'exemple, BERT, l'un des modèles Transformers les plus connus, effectue une classification de sentiment sur un texte. Voici comment le Transformer justifie la classification de texte en comprenant le langage pré-entraîné et en n'utilisant qu'un entraînement supplémentaire minimal :
from transformers import BertTokenizer, BertForSequenceClassification
import torch
# Load pre-trained BERT
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')
# Prepare input
text = "This movie was fantastic!"
inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
# Get predictions
with torch.no_grad():
outputs = model(**inputs)
predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
print(f"Prediction scores: {predictions}")
Dans le code ci-dessus, le tokenizer convertit la séquence de texte en tokens numériques (que BERT comprend) et en tokens spéciaux, tels que [CLS] (pour la classification), au début de la liste des tokens. BERT modélise ensuite toute la longueur de la phrase en utilisant plusieurs couches, où chaque couche est capable d'apprendre des représentations abstraites de sens.
Comment utiliser le NLP dans diverses industries
Vous pouvez utiliser le NLP pour résoudre des problèmes dans presque tous les secteurs, et il existe de nombreuses implémentations spécifiques à chaque secteur. Vous pouvez choisir d'essayer les extraits ci-dessous en fonction du domaine qui vous intéresse le plus.
Tourisme et hôtellerie
Vous pouvez utiliser les techniques de NLP pour construire des systèmes de réservation intelligents qui comprennent les demandes en langage naturel des clients. Utilisations importantes que vous pouvez appliquer :
L'analyse de sentiment surveille les commentaires des consommateurs pour repérer les tendances de satisfaction et les problèmes de service client.
Les chatbots compatibles NER récupèrent les dates et les lieux à partir des demandes des consommateurs telles que "J'ai besoin d'un vol pour Paris mardi prochain."
Voici un exemple :
from transformers import pipeline
# Load NER model
ner = pipeline("ner", grouped_entities=True)
# Extract booking information
query = "I need a hotel in London from December 15 to December 20"
entities = ner(query)
for entity in entities:
print(f"{entity['entity_group']}: {entity['word']}")
# Output: LOC: London
Grâce à la traduction automatique, vous pouvez fournir un support multilingue à vos clients dans diverses langues. Et un modèle de classification d'intention basé sur BERT identifie automatiquement comment diriger vos clients vers le service approprié ou effectue des réservations automatiquement pour eux.
Logistique et chaîne d'approvisionnement
Vous pouvez automatiser le traitement des documents via le NLP et optimiser l'acheminement des livraisons à l'aide d'algorithmes prédictifs. Voyons les domaines d'application courants :
- Vous pouvez utiliser l'OCR pour traiter les documents afin d'extraire automatiquement les informations d'expédition des factures et des formulaires de douane. Voici un exemple :
import pytesseract
from PIL import Image
# Extract text from shipping document
image = Image.open('invoice.png')
text = pytesseract.image_to_string(image)
# Parse extracted information
# (Add parsing logic based on document structure)
La classification de texte peut placer les expéditions dans des catégories basées sur les descriptions, permettant un tri récursif des expéditions pour le transport.
Les modèles de routage prédictif peuvent utiliser les données de livraison historiques et les rapports météorologiques pour créer des calendriers de livraison.
La génération de langage naturel (NLG) prend les données techniques de la logistique pour créer des mises à jour de suivi conviviales pour l'utilisateur.
Commerce de détail et e-commerce
Au sein des opérations d'e-commerce, vous pouvez personnaliser l'expérience d'achat de vos clients et optimiser les prix avec des techniques de NLP.
Quelques applications clés dont vous pouvez bénéficier :
- Les moteurs de recommandation utilisent les Embeddings de mots pour apprendre les descriptions de produits et les avis d'utilisateurs correspondants afin de suggérer des articles pertinents. Voici comment, par exemple :
from sentence_transformers import SentenceTransformer, util
# Load embedding model
model = SentenceTransformer('all-MiniLM-L6-v2')
# Product descriptions
products = [
"Wireless Bluetooth headphones with noise cancellation",
"USB-C charging cable for smartphones",
"Noise-cancelling earbuds with long battery life"
]
# User query
query = "I need headphones that block outside noise"
# Calculate similarities
query_embedding = model.encode(query)
product_embeddings = model.encode(products)
similarities = util.cos_sim(query_embedding, product_embeddings)
# Find best match
best_match_idx = similarities.argmax()
print(f"Recommended product: {products[best_match_idx]}")
Les chatbots incluant la gestion du dialogue peuvent répondre aux demandes des clients concernant les produits, les commandes et les retours.
L'analyse de sentiment sur les réseaux sociaux suit la santé de la marque et le sentiment des clients en temps réel.
Les algorithmes d'optimisation des prix analysent les prix des concurrents et les signaux du marché pour modifier les prix en temps réel.
La prévision de la demande analyse les actualités et le sentiment social pour prédire les besoins en stocks.
Santé
Le secteur de la santé, avec sa grande quantité de données provenant des dossiers des patients, est un domaine naturel pour l'optimisation par le NLP. Vous pouvez soutenir la prise de décision clinique et traiter les dossiers médicaux à l'aide de systèmes de NLP spécialisés.
Voici quelques-unes des utilisations possibles et un exemple :
- Le NER clinique identifie les conditions, les médicaments et les traitements mentionnés dans les notes des cliniciens au sein des dossiers de santé électroniques. Par exemple :
import spacy
# Load medical NER model (requires installation of scispacy)
# pip install scispacy
# pip install https://s3-us-west-2.amazonaws.com/ai2-s2-scispacy/releases/en_core_sci_sm-0.5.1.tar.gz
nlp = spacy.load("en_core_sci_sm")
# Process clinical note
text = "Patient presents with hypertension and type 2 diabetes. Prescribed metformin 500mg."
doc = nlp(text)
for ent in doc.ents:
print(f"{ent.text}: {ent.label_}")
Les systèmes d'aide à la décision clinique scannent les descriptions de symptômes et fournissent des suggestions de diagnostics potentiels pour aider à la prise de décision d'un médecin.
L'exploration de la littérature (Literature mining) scanne les études cliniques et identifie de nouveaux schémas de traitement ou des cibles potentielles pour la découverte de médicaments.
Bien sûr, le NLP peut également être utilisé dans les chatbots d'assistance aux patients, car ils peuvent comprendre le langage naturel et ses nuances.
Services financiers
Dans le secteur de la finance, vous pourriez être confronté à des goulots d'étranglement uniques. Les failles de sécurité des données financières et les risques de fraude figurent parmi les plus menaçants, tout comme les amendes réglementaires qui accompagnent ces problèmes.
Avec le NLP, vous pouvez améliorer les mécanismes de sécurité et créer des systèmes de détection de fraude.
Vous pouvez également détecter les attaques de phishing avec une grande précision grâce aux classificateurs de ML et au NLP utilisant des CNN et des RNN combinés. (Source : Saidat and others, ResearchGate).
Quelques autres cas d'utilisation incluent :
L'analyse de documents traite les demandes de prêt/contrats pour évaluer le risque de crédit par une analyse automatisée des documents.
Les systèmes de détection de fraude analysent les données de transaction et les données de communication pour identifier les activités suspectes. Par exemple :
from transformers import pipeline
# Load zero-shot classification model
classifier = pipeline("zero-shot-classification")
# Analyze transaction description
description = "Wire transfer to offshore account for investment opportunity"
candidate_labels = ["legitimate transaction", "potential fraud", "suspicious activity"]
result = classifier(description, candidate_labels)
print(f"Classification: {result['labels'][0]} (Score: {result['scores'][0]:.4f})")
La surveillance automatisée de la conformité scanne les messages pour vérifier le respect des réglementations.
Les robots-conseillers exploitent des interfaces en langage naturel pour interagir avec les clients tout en fournissant des conseils d'investissement.
En dehors de ces utilisations, les chatbots conventionnels fournissent également une assistance en utilisant des techniques de NLP. Les algorithmes d'OCR sont largement utilisés pour l'analyse de documents – mais nous avons déjà mentionné ces autres cas d'utilisation, nous n'en discuterons donc pas davantage ici.
Industrie juridique et réglementations de conformité
Plus encore que les services financiers, le secteur juridique dépend d'exigences, de lois et de réglementations strictes. Les techniques de NLP peuvent vous aider à améliorer la sûreté, la sécurité et l'efficacité du traitement des documents juridiques.
Exemples clés de la façon dont cela peut être appliqué :
L'authentification multimodale est un processus de vérification d'identité sécurisé consistant en une combinaison de reconnaissance faciale, de reconnaissance vocale et de traitement du langage naturel.
La reconnaissance du locuteur utilise l'encodage automatique de la parole en texte et la reconnaissance d'intention pour traiter une réponse verbale à des questions de sécurité.
L'analyse de contrat scanne les documents juridiques pour identifier les termes clés, les livrables et les dates, en extrayant ces informations automatiquement. À titre d'exemple, vous pouvez essayer l'extrait suivant avec la bibliothèque spaCy installée :
import spacy
nlp = spacy.load("en_core_web_sm")
# Extract dates and obligations from contract
contract_text = "The agreement shall commence on January 1, 2026 and continue for a period of 12 months."
doc = nlp(contract_text)
for ent in doc.ents:
if ent.label_ in ["DATE", "CARDINAL"]:
print(f"{ent.label_}: {ent.text}")
- La surveillance de la conformité recherche d'éventuelles infractions réglementaires dans les communications juridiques.
Ces exemples du monde réel montrent comment le NLP peut être utilisé pour résoudre des problèmes commerciaux pratiques et stimuler l'efficacité opérationnelle. Vous pouvez modifier les échantillons selon votre cas ou découvrir d'autres utilisations potentielles, mais ce sont les plus répandues que vous puissiez essayer.
Comment choisir les outils et bibliothèques de NLP les plus efficaces
Il existe une grande variété d'outils et de bibliothèques qui peuvent vous aider à apprendre à utiliser le NLP ou que vous pouvez utiliser pour implémenter le NLP dans un projet. Vous devriez sélectionner les outils appropriés en tenant compte des besoins de votre projet et de votre expérience dans les technologies associées.
Vous trouverez ci-dessous quelques outils populaires que vous pouvez choisir d'apprendre ou de consulter, ainsi que des conseils sur le moment où ils sont les plus utiles.
Hugging Face Transformers
Hugging Face Transformers possède des milliers de modèles pré-entraînés pour la génération de texte, la classification et les questions-réponses. Il prend en charge plus de 100 langues et est compatible avec PyTorch et TensorFlow.
Il fournit également l'hébergement de modèles et des jeux de données, et permet la collaboration avec les membres de la communauté. Il vous aidera pour les applications de Deep Learning NLP qui nécessitent des logiciels de pointe pour implémenter les algorithmes.
NLTK (Natural Language Toolkit)
NLTK est le package principal en Python pour l'éducation et la recherche concernant le NLP. Développé à l'Université de Pennsylvanie, il fournit des packages étendus pour vos tokeniseurs, stemmers, parseurs et le raisonnement sémantique. C'est un excellent choix si vous avez besoin d'apprendre les concepts du NLP ou de mener des projets de recherche.
spaCy
spaCy est une bibliothèque Python développée pour être prête pour la production, et possède le parseur syntaxique le plus rapide. Elle est construite en utilisant Cython pour une performance optimale et offre une excellente reconnaissance d'entités nommées. Elle conviendra bien si vous avez besoin d'un parsing de dépendances robuste et d'une API conviviale pour les développeurs. Il est facile pour vous d'utiliser spaCy pour un prototypage rapide.
Google Cloud NLP
Google Cloud NLP propose également des services d'API de niveau entreprise. Il conviendra à votre projet si vous avez besoin d'analyse de sentiment, de reconnaissance d'entités, d'analyse de syntaxe, d'identification automatique de la langue et d'une mise à l'échelle simple et sans problème. Et si vous êtes déjà dans l'écosystème Google Cloud travaillant avec de gros volumes de commentaires clients, c'est exactement ce qu'il vous faut.
Amazon Comprehend
Comprehend est un service entièrement géré d'AWS pour l'analyse de texte dans le cloud. Il prend en charge les fonctions majeures que vous pourriez vouloir couvrir : analyse de sentiment, reconnaissance d'entités, modélisation de sujets, protection intégrée des informations personnellement identifiables (PII) et mise à l'échelle automatique. Et c'est parfait si vous avez besoin d'une intégration intégrée avec la suite AWS.
IBM Watson
Watson possède des modèles de NLP spécifiques aux industries réglementées (santé, finance, etc.). Sa bibliothèque propose des modèles pré-entraînés dans 20 langages de programmation. Ses principales caractéristiques que vous pouvez utiliser sont des contrôles de données robustes, un accès fiable à l'API REST et des sorties véritablement prêtes pour la conformité. Cela fait de cet outil un excellent choix si vous travaillez dans les secteurs de la santé, de la finance ou du droit.
TextBlob
TextBlob est une bibliothèque simplifiée qui est une excellente option si vous êtes débutant. C'est une bibliothèque Python conviviale pour les tâches de NLP courantes. Pour votre commodité, elle offre une conception d'API simplifiée, tout en fournissant une analyse de sentiment, une traduction, une correction orthographique et une extraction de syntagmes nominaux décentes. En dehors des projets pour débutants, elle conviendra à vos besoins de création rapide de prototypes.
Comment préparer et entraîner des systèmes de NLP
Alors que vous vous préparez à entraîner votre modèle NLP, vous devrez préparer vos données avec précision pour vous assurer que leur qualité n'entrave pas les résultats. N'oubliez pas que des données de mauvaise qualité entraînent un modèle peu performant, vous voudrez donc vous assurer d'avoir des données solides.
Comprendre la qualité des données et le prétraitement
Les données textuelles brutes sont désordonnées et non structurées. Elles contiennent des fautes de frappe, de l'argot et des informations non pertinentes qui dégradent les performances de votre modèle.
Le prétraitement est l'opération qui prend des données désordonnées et les convertit en texte propre et structuré que les modèles peuvent accepter comme entrée.
La recherche montre que 85,4 % des études de recherche en NLP ont utilisé une sorte de restructuration/prétraitement pour permettre aux modèles NLP de traiter le texte brut. Les composants clés de la qualité des données qui étaient essentiels incluaient la précision (68,3 %), la pertinence (34,1 %) et la comparabilité (31,7 %). (Source : Nesca and others, NCBI).
Le prétraitement se résume à une liste spécifique de tâches que vous devrez effectuer. Décomposons-les.
Nettoyage du texte
Le nettoyage du texte est le processus de standardisation du format du texte en supprimant tout ce qui peut affecter l'entraînement du modèle. Le texte brut contient souvent des éléments supplémentaires (balises HTML, URL, caractères spéciaux, utilisation incohérente de la capitalisation et espaces excédentaires) qui ajoutent du bruit à vos données.
L'exemple suivant montre un pipeline de nettoyage qui supprime les éléments mentionnés ci-dessus. Cette fonction effectue plusieurs étapes de nettoyage de texte :
import re
def clean_text(text):
# Convert to lowercase
text = text.lower()
# Remove HTML tags
text = re.sub(r'<[^>]+>', '', text)
# Remove URLs
text = re.sub(r'http\S+|www.\S+', '', text)
# Remove special characters and numbers
text = re.sub(r'[^a-zA-Z\s]', '', text)
# Remove extra whitespace
text = ' '.join(text.split())
return text
# Example
raw_text = "Check out https://example.com! It's <b>AMAZING</b> :-)"
cleaned = clean_text(raw_text)
print(cleaned)
# Output: check out its amazing
La première étape effectuée par le modèle a été de tout convertir en minuscules pour l'uniformité. Ensuite, il a utilisé des expressions régulières pour analyser le texte afin de supprimer les balises HTML, les URL, les caractères spéciaux et les nombres. Enfin, il a normalisé les espaces en divisant et en rejoignant le texte. Le résultat est un texte propre, dans un format standardisé que vous pouvez utiliser pour la tokenisation.
Tokenisation
L'étape suivante consiste à diviser le texte en morceaux plus petits et digestibles qui sont plus faciles à comprendre pour les modèles de ML. Ces morceaux sont connus sous le nom de tokens.
La tokenisation se décline en trois variétés :
La tokenisation par mots sépare le texte selon la ponctuation et les espaces.
La tokenisation par phrases utilise des indices de ponctuation pour diviser le texte en phrases.
La tokenisation par sous-mots décompose les mots en morceaux plus maniables.
L'exemple ci-dessous traite des exemples de tokenisation par mots et par phrases en utilisant NLTK (Natural Language Toolkit).
from nltk.tokenize import word_tokenize, sent_tokenize
text = "Natural language processing is exciting! It helps computers understand text."
# Word tokenization
words = word_tokenize(text)
print(f"Words: {words}")
# Sentence tokenization
sentences = sent_tokenize(text)
print(f"Sentences: {sentences}")
Notez qu'après l'exécution de la tokenisation par mots, les signes de ponctuation '!' ou '.' ont été considérés comme des tokens individuels, car la ponctuation transmet du sens. La tokenisation par phrases a correctement identifié les limites des deux phrases et, malgré la présence d'un point d'exclamation, elle a indiqué qu'elle avait des règles plus complexes que le simple découpage basé sur les points.
Suppression des mots vides (Stop Words)
Ici, vous réduisez le texte à son sens essentiel sans détails superflus. Vous pouvez le faire en supprimant les mots couramment utilisés qui ont peu de valeur sémantique – les « mots vides » (stop words).
Les mots vides courants incluent les articles, les prépositions, les pronoms, les verbes auxiliaires et les conjonctions. Voici comment faire :
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
nltk.download('stopwords')
text = "The quick brown fox jumps over the lazy dog"
tokens = word_tokenize(text.lower())
stop_words = set(stopwords.words('english'))
filtered_tokens = [word for word in tokens if word not in stop_words]
print(f"Original: {tokens}")
print(f"Filtered: {filtered_tokens}")
# Output: ['quick', 'brown', 'fox', 'jumps', 'lazy', 'dog']
Racinisation (Stemming) et Lemmatisation
Dans cette étape suivante, vous traiterez davantage le texte en réduisant les mots à leur forme racine. Cela traitera les mots avec des variations similaires comme un seul token.
Pour être précis, la racinisation (stemming) consiste simplement à utiliser des règles heuristiques qui suppriment les terminaisons des mots. Par exemple (running|runs|run) → run.
La lemmatisation utilise l'analyse morphologique et le vocabulaire. Par exemple, (children|mice) → child|mouse.
La lemmatisation donne généralement de meilleurs résultats, plus précis (mais nécessite plus de calculs en même temps).
Voici comment vous pouvez appliquer les deux :
from nltk.stem import PorterStemmer, WordNetLemmatizer
stemmer = PorterStemmer()
lemmatizer = WordNetLemmatizer()
words = ["running", "runs", "ran", "children", "better"]
print("Stemming:")
for word in words:
print(f"{word} -> {stemmer.stem(word)}")
print("\nLemmatization:")
for word in words:
print(f"{word} -> {lemmatizer.lemmatize(word, pos='v')}")
Expansion des contractions
Les systèmes d'IA ont besoin de standardisation. Et les « don’ts » et « you’res » sont inacceptables pour eux. C'est pourquoi, typiquement, vous voudriez étendre la contraction au mot réel pour la standardisation. Voici comment vous pouvez faire cela :
import contractions
text = "I can't believe it's already 2025. We'll see what happens."
expanded = contractions.fix(text)
print(expanded)
# Output: I cannot believe it is already 2025. We will see what happens.
Correction des erreurs d'orthographe
Les erreurs orthographiques, d'orthographe ou de grammaire ne devraient pas figurer dans les données que vous fournissez à vos modèles de ML. Vous pouvez apporter des corrections à ces erreurs en utilisant des modèles de langage statistiques, qui peuvent prédire le mot le plus probablement visé, des algorithmes de distance d'édition qui peuvent trouver le mot valide le plus proche, ou des approches neuronales qui peuvent apprendre les motifs d'erreurs courantes.
Par exemple, voyons comment TextBlob, une bibliothèque qui utilise un mélange d'une approche basée sur un dictionnaire et de probabilité contextuelle, détecte et corrige les fautes d'orthographe.
from textblob import TextBlob
text = "Natral languag procesing is powrful"
corrected = TextBlob(text).correct()
print(f"Original: {text}")
print(f"Corrected: {corrected}")
TextBlob analyse chaque mot, identifie ceux qui ne sont pas dans son dictionnaire, calcule les distances d'édition, trouve les mots valides les plus similaires et sélectionne les corrections en fonction de la fréquence d'utilisation des mots dans le contexte.
Étiquetage morphosyntaxique (Parts-of-Speech Tagging)
L'étiquetage morphosyntaxique (POS tagging) consiste à attribuer une classification grammaticale aux mots en fonction de leur rôle dans une phrase. C'est important car le même mot peut fonctionner comme une partie du discours différente selon le contexte. Par exemple, "walk" peut être un nom (comme "an evening walk") ou un verbe (comme "I walk to the office").
Les étiqueteurs POS s'appuient sur des modèles statistiques entraînés pour prédire le rôle grammatical le plus probable d'un mot étant donné le contexte. Le code suivant montre l'étiquetage POS à l'aide de NLTK, qui applique un modèle pré-entraîné qui étiquettera la structure grammaticale.
import nltk
text = "The cat sat on the mat"
tokens = nltk.word_tokenize(text)
pos_tags = nltk.pos_tag(tokens)
for word, tag in pos_tags:
print(f"{word}: {tag}")
# Output:
# The: DT (Determiner)
# cat: NN (Noun)
# sat: VBD (Verb, past tense)
La fonction pos_tag() évalue chaque token et lui attribue une notation standardisée. Par exemple, DT indique les déterminants (tels que "the"), NN indique les noms singuliers, VBD indique les verbes au passé et IN indique les prépositions. L'étiqueteur peut également utiliser le contexte pour prendre ces décisions : il peut déterminer que "sat" est VBD et non NN parce qu'il apparaît après un nom et avant une préposition, ce qui sont tous des motifs typiques de la phrase anglaise.
Établissement et étiquetage de jeux de données
Pour les tâches d'apprentissage supervisé telles que l'analyse de sentiment, le NER ou la classification, les données non étiquetées sont inutiles.
C'est pourquoi, pour créer des jeux de données d'entraînement, vous devez annoter les données brutes avec des étiquettes pertinentes. Les modèles peuvent apprendre des motifs et faire des prédictions grâce à cette « vérité terrain » (ground truth). Définissons les méthodes les plus courantes pour l'étiquetage.
Étiquetage automatisé basé sur des bibliothèques
Vous n'avez pas toujours besoin de créer des étiquettes à partir de zéro. Des bibliothèques comme TextBlob ont des modèles d'analyse de sentiment intégrés entraînés sur de grands jeux de données qui étiquettent le texte. Elles exécutent un score de polarité (un nombre qui représente le sentiment) et attribuent une étiquette catégorielle.
Par exemple, TextBlob examine le choix des mots, les modificateurs en particulier (des mots comme "very" ou "not"), et les motifs grammaticaux pour exécuter un score de polarité de -1 (le plus négatif) à +1 (le plus positif), zéro signifiant un sentiment neutre.
Dans cet exemple, nous étiquetons automatiquement les sentiments basés sur un analyseur de sentiment TextBlob pré-entraîné :
from textblob import TextBlob
def label_sentiment(text):
blob = TextBlob(text)
polarity = blob.sentiment.polarity
if polarity < 0:
return "negative"
elif polarity == 0:
return "neutral"
else:
return "positive"
# Example
texts = [
"I love this product!",
"It's okay, nothing special",
"Terrible experience, very disappointed"
]
for text in texts:
label = label_sentiment(text)
print(f"{text} -> {label}")
Étiquetage manuel
Dans de nombreux cas, l'étiquetage automatisé basé sur une bibliothèque n'est pas une option. Pour des normes spécifiques à un domaine, vous devriez annoter vos données à la main pour garantir la précision et la pertinence.
Pour les projets impliquant un étiquetage manuel :
Établissez des normes d'étiquetage précises. Fournissez une directive d'annotation qui définit chaque étiquette avec des critères clairs et des cas limites. À titre d'exemple, si vous annotez des tickets de support client, un exemple de critère potentiel devrait être que "J'ai besoin d'aide pour réinitialiser mon mot de passe" est "Support technique", et un autre exemple est "Quand ma commande arrivera-t-elle ?" qui est un exemple de "Demande de commande".
Pour le contrôle qualité, utilisez plusieurs annotateurs. Faites étiqueter les mêmes échantillons de données par 2 ou 3 personnes indépendamment. Par exemple, si vous annotez des symptômes médicaux, le fait d'avoir plusieurs annotateurs réduit mieux le risque de biais provenant de l'étiquetage d'une seule personne et peut protéger contre les erreurs de saisie.
Déterminez l'accord inter-annotateurs. Calculez les scores Kappa de Cohen ou Kappa de Fleiss pour mesurer la cohérence de l'accord entre les annotateurs. Un score supérieur à 0,80 signifierait un très bon accord, tandis qu'un score inférieur à 0,60 indiquerait que les directives d'étiquetage n'étaient pas assez claires pour les annotateurs.
Donnez des instructions et des illustrations. Créez un document de référence avec 20 à 30 exemples que vous avez pré-étiquetés, montrant des exemples de cas d'utilisation typiques et de cas limites. Par exemple, dans une analyse de sentiment, vous pouvez fournir des exemples de moments où un sentiment serait neutre, avec un exemple tel que "Ce produit est correct, je suppose", même s'il a pu sembler légèrement négatif. Un sentiment est également classé comme un bon exemple positif même s'il contient deux négations : "Pas mal du tout."
C'est la référence absolue pour des jeux de données de haute qualité, mais c'est aussi chronophage et coûteux – étiqueter 10 000 avis clients pourrait prendre une semaine s'il est fait manuellement.
Approches avec semi-supervision
Il existe des cas où vous devriez combiner les approches précédentes. Cette méthode semi-supervisée utilise un petit ensemble de données étiquetées manuellement (données de haute qualité) et un grand pool de données non étiquetées (données peu coûteuses, en grandes quantités).
La méthode fonctionne par auto-entraînement itératif, où vous entraînez d'abord le modèle sur votre petit jeu de données étiquetées, puis prédisez les étiquettes sur les données non étiquetées à l'aide de ce modèle, puis ajoutez les prédictions les plus confiantes à vos données d'entraînement pendant l'entraînement, et ré-entraînez. Le processus d'auto-entraînement est ensuite répété, améliorant et élargissant progressivement votre jeu de données étiquetées.
Voici un exemple d'auto-entraînement en pratique : ce code démontre le workflow semi-supervisé.
from sklearn.semi_supervised import SelfTrainingClassifier
from sklearn.svm import SVC
# Small labeled dataset + large unlabeled dataset
X_labeled = [[1, 2], [3, 4], [5, 6]]
y_labeled = [0, 1, 0]
X_unlabeled = [[2, 3], [4, 5], [6, 7]]
# Combine datasets (-1 represents unlabeled)
X_train = X_labeled + X_unlabeled
y_train = y_labeled + [-1, -1, -1]
# Self-training classifier
base_classifier = SVC(probability=True, gamma='auto')
self_training = SelfTrainingClassifier(base_classifier)
self_training.fit(X_train, y_train)
Le code montre une version du SelfTrainingClassifier qui s'entraîne d'abord sur les trois exemples étiquetés, puis utilise le modèle pour prédire les entrées et les étiquettes pour les données non étiquetées. Le classificateur sélectionne ensuite les prédictions où il a une grande confiance (par exemple, les prédictions qui ont une probabilité > 90 %) tout en les utilisant comme de nouvelles données étiquetées. Le classificateur se ré-entraîne ensuite, et le processus continue.
Alors, comment décidez-vous quelle approche conviendra à vos besoins ? Dans la plupart des cas, l'approche optimale dépendra des aspects suivants :
Budget et temps disponibles.
Précision souhaitée.
Taille du jeu de données.
Complexité du domaine.
Comme vous le voyez, les approches varient et peuvent être mélangées de temps à autre. L'essentiel est de s'assurer que les entrées pour le traitement final de pré-génération sont nettoyées, standardisées et étiquetées. Rappelez-vous le principe clé : « À données erronées, résultats erronés » (Garbage in, garbage out). Envoyez de l'or à la place, et bonne chance !
Conclusion
À ce stade, vous devriez connaître les bases du travail avec des projets NLP.
Tout au long de cet article, vous avez appris :
Comment configurer votre environnement de développement NLP à l'aide d'un ensemble d'outils et de bibliothèques.
Les cinq parties des systèmes de NLP et comment elles sont utilisées pour traiter le langage.
Comment mener des tâches courantes comme le NER, l'analyse de sentiment et la classification de texte.
Comment choisir la bibliothèque à utiliser pour répondre aux besoins de votre projet.
Comment préparer et étiqueter des jeux de données pour l'entraînement.
Comment trouver les applications pratiques clés du NLP adaptées à votre industrie et à votre cas d'utilisation.
Prochaines étapes
Essayez de commencer par un projet simple, comme l'analyse de sentiment, qui utilise des modèles pré-entraînés.
Pratiquez les méthodes de prétraitement avec vos propres données textuelles.
Utilisez et essayez différentes bibliothèques pour voir comment obtenir le meilleur résultat pour votre projet.
Construisez un pipeline complet, de la préparation des données textuelles au déploiement des modèles.
Continuez à pratiquer et découvrez des applications avancées comme les modèles Transformers et le fine-tuning.
Plus important encore, gardez à l'esprit que le NLP est un processus itératif. Commencez petit, testez de manière appropriée pour que cela fonctionne, puis augmentez la complexité lorsque vous serez plus à l'aise et sûr de vos capacités et de votre familiarité avec les pratiques.
À propos de l'auteur
J'espère que vous avez apprécié l'article et que vous l'avez trouvé utile. Je contribue à freeCodeCamp depuis plus de 8 ans, et pour rendre cette pièce plus précise et détaillée, j'ai utilisé l'aide d'experts.
Je suis reconnaissant pour les idées techniques de mes collègues chez COAX Software qui ont souhaité rester anonymes. L'entreprise est une société de développement AI/ML réputée.
Pour en savoir plus sur moi et lire plus de contenu sur la technologie et le numérique, vous pouvez visiter ma page LinkedIn.