Mise en route du traitement du langage naturel en Python –

Une partie importante des données générées aujourd'hui est non structurée. Les données non structurées incluent les commentaires sur les réseaux sociaux, l'historique de navigation et les commentaires des clients. Vous êtes-vous retrouvé dans une situation avec un tas de données textuelles à analyser et vous ne savez pas comment procéder? Le traitement du langage naturel en Python peut aider.

L'objectif de ce tutoriel est de vous permettre d'analyser des données textuelles en Python à l'aide des concepts de traitement du langage naturel. Vous allez d'abord apprendre à scinder votre texte en fragments plus petits, à normaliser les mots à leur forme racine, puis à supprimer tout bruit dans vos documents pour les préparer à une analyse plus poussée.

On commence!

Conditions préalables

Dans ce didacticiel, nous allons utiliser la bibliothèque nltk de Python pour effectuer toutes les opérations de la PNL sur le texte. Au moment de la rédaction de ce tutoriel, nous utilisions la version 3.4 de nltk . Pour installer la bibliothèque vous pouvez utiliser la commande pip sur le terminal:

 pip install nltk == 3.4

Pour vérifier quelle version de nltk existe dans le système, vous pouvez importer la bibliothèque dans l'interpréteur Python et vérifier la version:

 import nltk
print (nltk .__ version__)

Pour effectuer certaines actions dans nltk de ce didacticiel, vous devrez peut-être télécharger des ressources spécifiques. Nous allons décrire chaque ressource selon les besoins.

Toutefois, si vous souhaitez éviter de télécharger des ressources individuelles plus tard dans le didacticiel et les récupérer maintenant, exécutez la commande suivante:

 python -m nltk.downloader tout

Étape 1: conversion en jetons

Un système informatique ne peut pas trouver une signification en langage naturel seul. La première étape du traitement du langage naturel consiste à convertir le texte original en jetons. Un jeton est une combinaison de caractères continus, avec une certaine signification. C'est à vous de décider comment décomposer une phrase en jetons. Par exemple, une méthode simple consiste à diviser une phrase par des espaces pour la diviser en mots individuels.

Dans la bibliothèque NLTK, vous pouvez utiliser la fonction word_tokenize () pour convertir une chaîne en jetons. Cependant, vous devrez d'abord télécharger la ressource punkt . Exécutez la commande suivante dans le terminal:

 nltk.download ('punkt')

Ensuite, vous devez importer word_tokenize de nltk.tokenize pour l'utiliser.

 de nltk.tokenize import word_tokenize
print (word_tokenize ("Bonjour, c’est un bon hôtel."))

La ​​sortie du code est la suivante:

 ['Hi', ',', 'this', 'is', 'a', 'nice', 'hotel', '.']

Vous remarquerez que word_tokenize ne divise pas simplement une chaîne basée sur les espaces, mais sépare également la ponctuation en jetons. À vous de décider si vous souhaitez conserver les signes de ponctuation dans l'analyse.

Étape 2: conversion des mots en leurs formes de base

Lorsque vous traitez un langage naturel, vous remarquerez souvent qu'il existe différentes formes grammaticales. du même mot. Par exemple, “aller”, “aller” et “parti” sont des formes du même verbe, “aller”.

Bien que les nécessités de votre projet puissent vous obliger à conserver les mots sous différentes formes grammaticales, discutez-en un moyen convertir différentes formes grammaticales du même mot en sa forme de base. Vous pouvez utiliser deux techniques pour convertir un mot à sa base.

La première technique consiste à stemming. La recherche de racine est un algorithme simple qui supprime les affixes d'un mot. Il y a divers algorithmes de stemming disponibles pour être utilisés dans NLTK. Nous allons utiliser l'algorithme de Porter dans ce tutoriel.

Nous avons d'abord importé PorterStemmer de nltk.stem.porter . Nous initialisons ensuite le stemmer à la variable stemmer puis nous utilisons la méthode .stem () pour trouver la forme de base d'un mot.

 de nltk.stem.porter import PorterStemmer
stemmer = PorterStemmer ()
print (stemmer.stem ("aller"))

La ​​sortie du code ci-dessus est go . Si vous exécutez le stemmer pour les autres formes de «go» décrites ci-dessus, vous remarquerez qu'il renvoie la même forme de base, «go». Toutefois, comme l’approche par tige n’est qu’un simple algorithme basé sur la suppression des affixes de mots, elle échoue lorsque les mots sont moins couramment utilisés dans la langue.

Lorsque vous essayez l’option “constitue”, vous obtenez un résultat non intuitif. [19659006] print (stemmer.stem ("constitue"))

Vous remarquerez que la sortie est «constitut».

Ce problème est résolu en passant à une approche plus complexe de la recherche de la forme de base d'un mot dans un contexte donné. Le processus s'appelle lemmatisation. La lemmatisation normalise un mot en fonction du contexte et du vocabulaire du texte. Dans NLTK, vous pouvez lemmatiser des phrases à l'aide de la classe WordNetLemmatizer .

Tout d'abord, vous devez télécharger la ressource wordnet à partir du programme de téléchargement NLTK dans le terminal Python.

 nltk. télécharger ('wordnet')

Une fois le téléchargement effectué, vous devez importer la classe WordNetLemmatizer et l'initialiser.

 à partir de nltk.stem.wordnet import WordNetLemmatizer
lem = WordNetLemmatizer ()

Pour utiliser le lemmatiseur, utilisez la méthode .lemmatize () . Il faut deux arguments – le mot et le contexte. Dans notre exemple, nous allons utiliser «v» pour le contexte. Examinons plus en profondeur le contexte après avoir examiné le résultat de la méthode .lemmatize () .

 print (lem.lemmatize ('constitue', 'v'))

Vous remarquerez que la méthode .lemmatize () convertit correctement le mot «constitue» en sa forme de base, «constitue». Vous remarquerez également que la lemmatisation prend plus de temps que la racine, car l’algorithme est plus complexe.

Voyons maintenant comment déterminer le deuxième argument de la méthode .lemmatize () par programmation. NLTK a une fonction pos_tag qui aide à déterminer le contexte d'un mot dans une phrase. Cependant, vous devez d'abord télécharger la ressource averaged_perceptron_tagger via le téléchargeur NLTK.

 nltk.download ('averaged_perceptron_tagger')

Ensuite, importez la fonction pos_tag et exécutez-la sur une phrase.

 à partir de nltk.tag import pos_tag
sample = "Bonjour, c’est un bon hôtel."
print (pos_tag (word_tokenize (exemple)))

Vous remarquerez que le résultat est une liste de paires. Chaque paire consiste en un jeton et sa balise, ce qui signifie le contexte d'un jeton dans le texte global. Notez que l'étiquette pour la ponctuation est elle-même.

 [('Hi', 'NNP'),
 (',', ','),
 ('this', 'DT'),
 ('is', 'VBZ'),
 ('a', 'DT'),
 ('nice', 'JJ'),
 ('hotel', 'NN'),
 ('.', '.')]

Comment décodez-vous le contexte de chaque jeton? Voici une liste complète de tous les tags et de leurs significations correspondantes sur le Web. Notez que les balises de tous les noms commencent par «N» et que, pour tous les verbes, elles commencent par «V». Nous pouvons utiliser cette information dans le deuxième argument de notre méthode .lemmatize () .

 def lemmatize_tokens (stentence):
    lemmatizer = WordNetLemmatizer ()
    lemmatized_tokens = []
    pour mot, tag dans pos_tag (stentence):
        si tag.startswith ('NN'):
            pos = 'n'
        elif tag.startswith ('VB'):
            pos = 'v'
        autre:
            pos = 'a'
        lemmatized_tokens.append (lemmatizer.lemmatize (word, pos))
    retourne lemmatized_tokens

sample = "L'autorité légale constitue tous les magistrats."
print (lemmatize_tokens (word_tokenize (exemple)))

La ​​sortie du code ci-dessus est la suivante:

 ['Legal', 'authority', 'constitute', 'all', 'magistrate', '.']

Cette sortie correspond aux motifs attendus, où «constitue» et «magistrats» ont été convertis respectivement en «constituent» et «magistrat».

Étape 3: Nettoyage des données

L'étape suivante de la préparation des données est nettoyer les données et supprimer tout ce qui n’ajoute rien à votre analyse. Globalement, nous examinerons la possibilité de supprimer la ponctuation et d'arrêter les mots de votre analyse.

La suppression de la ponctuation est une tâche assez facile. L'objet de ponctuation de la bibliothèque de chaînes contient tous les signes de ponctuation en anglais.

 import string
print (string.punctuation)

Le résultat de cet extrait de code est le suivant:

 '! "# $% & ' () * +, -. / :; <=>? @ [\] ^ _` {|} ~ '

Pour supprimer la ponctuation des jetons, vous pouvez simplement exécuter:

 pour le jeton dans les jetons:
    si jeton dans string.punctuation:
        # Faire quelque chose

Ensuite, nous nous concentrerons sur la suppression des mots vides. Les mots vides sont des mots couramment utilisés dans les langages tels que «I», «a» et «le», qui donnent peu de sens au texte lors de son analyse. Nous allons donc supprimer les mots vides de notre analyse. Tout d’abord, téléchargez la ressource stopwords à partir du programme de téléchargement NLTK.

 nltk.download ('mots vides')

Une fois le téléchargement terminé, importez stopwords de nltk.corpus et utilisez la méthode .words () avec l'argument «anglais». C'est une liste de 179 mots vides en anglais.

 de nltk.corpus import stopwords
stop_words = stopwords.words ('anglais')

Nous pouvons combiner l'exemple de lemmatisation avec les concepts abordés dans cette section pour créer la fonction suivante, clean_data () . De plus, avant de comparer si un mot fait partie de la liste des mots vides, nous le convertissons en minuscule. De cette façon, nous capturons toujours un mot d'arrêt s'il apparaît au début d'une phrase et qu'il est en majuscule.

 def clean_data (tokens, stop_words = ()):

    cleaner_tokens = []

    pour le jeton, balise dans pos_tag (jetons):
        si tag.startswith ("NN"):
            pos = 'n'
        elif tag.startswith ('VB'):
            pos = 'v'
        autre:
            pos = 'a'

        lemmatizer = WordNetLemmatizer ()
        jeton = lemmatizer.lemmatize (jeton, pos)

        Si le jeton n'est pas dans string.punctuation et token.lower () pas dans stop_words:
            cleaner_tokens.append (jeton)
    retourne clean_tokens

sample = "Le renard brun rapide saute par-dessus le chien paresseux."
stop_words = stopwords.words ('anglais')

clean_data (word_tokenize (exemple), stop_words)

Le résultat de l'exemple est le suivant:

 ['quick', 'brown', 'fox', 'jump', 'lazy', 'dog']

Comme vous pouvez le constater, la ponctuation et les mots vides ont été supprimés

Distribution de la fréquence des mots

Maintenant que vous connaissez les techniques de nettoyage de base de la PNL, voyons la fréquence des mots dans le texte. Pour cet exercice, nous allons utiliser le texte du conte de fées The Mouse, The Bird and The Sausage disponible gratuitement sur Gutenberg. Nous allons stocker le texte de ce conte de fées dans une chaîne, texte .

Premièrement, nous tokenisons le texte puis nous le nettoyons à l'aide de la fonction clean_data que nous avons défini ci-dessus.

 tokens = word_tokenize (text)
cleaner_tokens = clean_data (jetons, stop_words = stop_words)

Pour trouver la distribution de fréquence des mots dans votre texte, vous pouvez utiliser la classe FreqDist de NLTK. Initialisez la classe avec les jetons en tant qu'argument. Utilisez ensuite la méthode .most_common () pour rechercher les termes courants. Essayons de trouver les dix termes les plus fréquents dans cette affaire.

 from nltk import FreqDist

freq_dist = FreqDist (clean_tokens)
freq_dist.most_common (10)

Voici les dix termes les plus couramment utilisés dans ce conte de fées.

python
[('oiseau'15)
('saucisse', 11),
( 'souris', 8),
('bois', 7),
('temps', 6),
('long', 5),
('marque', 5) ,
('fly', 4),
('fetch', 4),
('water', 4)]


Sans surprise, les trois termes les plus utilisés sont les trois personnages principaux du conte de fées.

La fréquence des mots peut ne pas être très importante lors de l'analyse de texte. La prochaine étape de la PNL consiste généralement à générer une statistique - TF - IDF (fréquence de documents - fréquence inverse des documents), qui indique l’importance d’un mot dans une liste de documents.

Conclusion [19659005] Dans cet article, vous avez été initié au traitement du langage naturel en Python. Vous avez converti du texte en jetons, converti des mots en formes de base et enfin nettoyé le texte pour supprimer toute partie qui n'ajoutait pas de sens à l'analyse.

Bien que vous ayez examiné de simples tâches de PNL dans ce tutoriel, de nombreuses techniques sont disponibles. explorer. On peut souhaiter effectuer une modélisation de sujet sur des données textuelles, l'objectif étant de trouver un sujet commun pouvant faire l'objet d'un texte. Une tâche plus complexe de la PNL est la mise en œuvre de un modèle d'analyse des sentiments pour déterminer le sentiment qui se cache derrière un texte.

Quelles procédures suivez-vous lorsque vous disposez d'une pile de texte avec laquelle travailler? Faites-nous savoir dans les commentaires ci-dessous.

Shaumik est un optimiste, mais un parapluie. Roorkee, un étudiant de premier cycle de l’Institut indien de technologie, et cofondateur de The Blog Bowl, il adore écrire, alors qu’il n’est pas occupé à garder le drapeau bleu à l’arrière.