Racinage et lemmatisation dans Python NLTK avec exemples

Qu'est-ce que la tige et la lemmatisation Python NLTK ?

Racisme et lemmatisation in Python NLTK regroupe des techniques de normalisation de texte pour le traitement automatique du langage naturel. Ces techniques sont largement utilisées pour le prétraitement des textes. La différence entre la racinisation et la lemmatisation réside dans le fait que la racinisation est plus rapide car elle supprime les mots sans tenir compte du contexte, tandis que la lemmatisation est plus lente car elle prend en compte le contexte des mots avant le traitement.

Qu’est-ce que le stemming ?

Stemming est une méthode de normalisation des mots dans Traitement du langage naturelIl s'agit d'une technique qui consiste à convertir un ensemble de mots d'une phrase en une séquence afin de raccourcir la recherche. Cette méthode normalise les mots ayant le même sens mais présentant des variations selon le contexte ou la phrase. Autrement dit, il existe un mot racine, mais de nombreuses variantes de ce même mot. Par exemple, le mot racine est « manger » et ses variantes sont « mange », « mangeant », « mangé », etc. De la même manière, grâce à la racinisation… Python, nous pouvons trouver le mot racine de n'importe quelle variante.

Par exemple :

He was riding.
He was taking the ride.

Dans les deux phrases ci-dessus, le sens est identique : il s'agit d'une activité équestre passée. Un humain comprend aisément cette équivalence. En revanche, pour les machines, ces deux phrases sont différentes. Il devient donc difficile de les convertir en une même ligne de données. Si l'on ne fournit pas un ensemble de données identique, la machine ne parvient pas à effectuer de prédiction. Il est donc nécessaire de différencier le sens de chaque mot afin de préparer un ensemble de données adapté à l'apprentissage automatique. La racinisation est ici utilisée pour catégoriser les données de même type en identifiant leur racine.

Mettons cela en œuvre avec un Python programme. NLTK possède un algorithme nommé Porter StemmerCet algorithme accepte la liste des mots tokenisés et les réduit à leurs racines.

Programme pour comprendre la dérivation

from nltk.stem import PorterStemmer
e_words= ["wait", "waiting", "waited", "waits"]
ps =PorterStemmer()
for w in e_words:
    rootWord=ps.stem(w)
    print(rootWord)

Sortie :

wait
wait
wait
wait

Code Explication:

• Il existe un module STEM dans NLTK qui est importé. Si vous importez le module complet, le programme deviendra très volumineux car il contient des milliers de lignes de code. C'est pourquoi, parmi tous les modules STEM, nous n'avons importé que « PorterStemmer ».
• Nous avons préparé une liste factice de données de variation du même mot.
• Un objet appartenant à la classe nltk.stem.porter.PorterStemmer est créé.
• Nous avons traité chaque mot de la liste un par un avec PorterStemmer à l'aide d'une boucle « for ». Finalement, nous avons obtenu la racine de chaque mot de la liste.

Comme indiqué précédemment, la racinisation est une étape de prétraitement importante car elle élimine les redondances et les variations d'un même mot. Les données sont ainsi filtrées, ce qui facilite l'apprentissage automatique. Nous allons maintenant soumettre une phrase complète et vérifier le résultat.

from nltk.stem import PorterStemmer
from nltk.tokenize import sent_tokenize, word_tokenize
sentence="Hello Guru99, You have to build a very good site and I love visiting your site."
words = word_tokenize(sentence)
ps = PorterStemmer()
for w in words:
	rootWord=ps.stem(w)
	print(rootWord)

Sortie :

hello
guru99
,
you
have
build
a
veri
good
site
and
I
love
visit
your
site

Code Explication:

• Le paquet PorterStemmer est importé du module stem.
• Des modules de tokenisation des phrases et des mots sont importés.
• Une phrase est écrite qui doit être symbolisée à l'étape suivante.
• Un objet pour PorterStemmer est créé ici.
• Une boucle est exécutée et la racinisation de chaque mot est effectuée à l'aide de l'objet créé à la ligne de code 5.

En résumé, la racinisation est un module de prétraitement des données. La langue anglaise comporte de nombreuses variations d'un même mot, ce qui crée des ambiguïtés lors de l'entraînement et de la prédiction par apprentissage automatique. Pour construire un modèle performant, il est essentiel de filtrer ces mots au sein d'une même séquence de données grâce à la racinisation. Ce processus est également appelé normalisation.

Qu’est-ce que la lemmatisation ?

Lemmatisation Dans NLTK, la lemmatisation est le processus algorithmique qui détermine le lemme d'un mot en fonction de son sens et de son contexte. Elle désigne généralement l'analyse morphologique des mots visant à supprimer leurs terminaisons flexionnelles. Elle permet de retrouver la forme de base ou la forme lexicale d'un mot, appelée lemme. La méthode de lemmatisation de NLTK repose sur la fonction morphologique intégrée de WordNet. Le prétraitement du texte comprend à la fois la racinisation et la lemmatisation. Ces deux termes sont souvent confondus, voire considérés comme synonymes. Or, il existe une différence entre la racinisation et la lemmatisation. La lemmatisation est privilégiée pour les raisons suivantes.

Pourquoi la lemmatisation est-elle meilleure que le stemming ?

L'algorithme de racinisation fonctionne en supprimant le suffixe du mot. Plus généralement, il supprime soit le début, soit la fin du mot. À l'inverse, la lemmatisation est une opération plus puissante qui prend en compte l'analyse morphologique des mots. Elle renvoie le lemme, qui est la forme de base de toutes ses formes flexionnelles. Une connaissance linguistique approfondie est nécessaire pour créer des dictionnaires et rechercher la forme correcte d'un mot. La racinisation est une opération générale, tandis que la lemmatisation est une opération intelligente qui consiste à rechercher la forme correcte dans un dictionnaire. Ainsi, la lemmatisation contribue à une meilleure formation des mots. machine learning d’APOB.

Code faire la distinction entre la lemmatisation et la racinisation

Stemming Code:

import nltk
from nltk.stem.porter import PorterStemmer
porter_stemmer  = PorterStemmer()
text = "studies studying cries cry"
tokenization = nltk.word_tokenize(text)
for w in tokenization:
print("Stemming for {} is {}".format(w,porter_stemmer.stem(w)))

Sortie :

Stemming for studies is studi
Stemming for studying is studi
Stemming for cries is cri
Stemming for cry is cri

Lemmatisation Code:

import nltk
	from nltk.stem import 	WordNetLemmatizer
	wordnet_lemmatizer = WordNetLemmatizer()
	text = "studies studying cries cry"
	tokenization = nltk.word_tokenize(text)
	 for w in tokenization:
		print("Lemma for {} is {}".format(w, wordnet_lemmatizer.lemmatize(w)))

Sortie :

Lemma for studies is study
Lemma for studying is studying
Lemma for cries is cry
Lemma for cry is cry

Discussion du résultat

Si l'on examine la racinisation de « studies » et « studying », le résultat est le même (« studi »), mais le lemmatiseur NLTK propose un lemme différent pour les deux mots : « study » pour « studys » et « studying » pour « study ». Par conséquent, lors de la création d'un ensemble de caractéristiques pour l'entraînement d'un modèle, il serait préférable que la lemmatisation soit privilégiée.

Cas d'utilisation du lemmatiseur

Le lemmatiseur minimise l'ambiguïté du texte. Des mots comme « bicyclette » ou « bicyclettes » sont convertis en leur forme de base « bicyclette ». Il convertit tous les mots ayant la même signification mais une orthographe différente en leur forme de base, réduisant ainsi la densité lexicale et facilitant le texte.ping Préparez des caractéristiques précises pour l'entraînement d'un modèle. Plus les données sont propres, plus votre modèle d'apprentissage automatique sera précis. Le lemmatiseur NLTK permet également de réduire la mémoire et les coûts de calcul.

Exemple en temps réel illustrant l'utilisation de la lemmatisation et de l'étiquetage morphosyntaxique WordNet dans Python:

from nltk.corpus import wordnet as wn
	from nltk.stem.wordnet import WordNetLemmatizer
	from nltk import word_tokenize, pos_tag
	from collections import defaultdict
	tag_map = defaultdict(lambda : wn.NOUN)
	tag_map['J'] = wn.ADJ
	tag_map['V'] = wn.VERB
	tag_map['R'] = wn.ADV
	text = "guru99 is a totally new kind of learning experience."
	tokens = word_tokenize(text)
	lemma_function = WordNetLemmatizer()
	for token, tag in pos_tag(tokens):
		lemma = lemma_function.lemmatize(token, tag_map[tag[0]])
		print(token, "=>", lemma)

Sortie :

guru99 => guru99
is => be
totally => totally
new => new
kind => kind
of => of
learning => learn
experience => experience
. => .

Code Explication:

• Le lecteur de corpus WordNet est importé, et WordNetLemmatizer est importé depuis WordNet.
• La tokenisation des mots et l'étiquetage grammatical sont importés de nltk, et le dictionnaire par défaut de collections.
• Un dictionnaire est créé où la première lettre de pos_tag est la clé, associée à la valeur du dictionnaire wordnet.
• Le texte est écrit et tokenisé, et l'objet lemme_function est créé pour être utilisé à l'intérieur de la boucle.
• La boucle est exécutée, et la fonction lemmatize prend deux arguments : le jeton et une carte.ping de pos_tag avec la valeur wordnet.

Python La lemmatisation est étroitement liée à la Dictionnaire WordNetIl est donc essentiel d'étudier ce sujet ensuite.

FAQ