Technologie

NLTK – SWAYAM MITTAL – Moyenne

NLTK - SWAYAM MITTAL - Moyenne


I. Analyser des mots et des phrases avec NLTK

Bienvenue dans la série de didacticiels de traitement du langage naturel, utilisant le module NLTK de la boîte à outils langage naturel de Python.

Le module NLTK est une énorme boîte à outils conçue pour vous aider avec l’ensemble de l’approche du traitement du langage naturel (PNL). NLTK vous fournira tout, du fractionnement de paragraphes aux phrases, en passant par la division de mots, l'identification de la partie du discours, la mise en évidence de thèmes et même d'aider votre machine à comprendre le contenu du texte. Dans cette série, nous aborderons les domaines de l'extraction d'opinions ou de l'analyse des sentiments.

En apprenant à utiliser NLTK pour l'analyse des sentiments, nous apprendrons ce qui suit:

  • Participe - divise le corps du texte en phrases et mots.
  • Une partie du marquage de la parole
  • Apprentissage automatique et classificateur naïf de Bayes
  • Comment utiliser Scikit Learn (sklearn) avec NLTK ensemble
  • Classificateurs de formation avec des ensembles de données
  • Analyse des sentiments en streaming en temps réel avec Twitter.
  • …et plus.

Pour commencer, vous avez besoin du module NLTK, ainsi que de Python.

Si vous n'avez pas déjà Python, allez à python.org et téléchargez la dernière version de Python (si vous êtes sous Windows). Si vous êtes sur Mac ou Linux, vous devriez pouvoir exécuter apt-get installez python3 .

Ensuite, vous avez besoin de NLTK 3. Le moyen le plus simple d’installer un module NLTK est d’utiliser pépin .

Pour tous les utilisateurs, cela se fait en ouvrant cmd.exe , bash, ou n’importe quel shell que vous utilisez et en tapant la commande suivante:

Pip installer nltk

Ensuite, nous devons installer certains composants pour NLTK. Ouvrez python à votre façon habituelle et tapez:

Importer Nltk
Nltk.download ()

Sélectionnez Télécharger tout pour tous les packages et cliquez sur Télécharger. Cela vous donnera tous les mots brisés, les bloqueurs, d'autres algorithmes et tous les corpus. Si l'espace est un problème, vous pouvez choisir de télécharger manuellement tout le contenu. Le module NLTK occupera environ 7 Mo et l’ensemble des nltk_data répertoire occupera environ nltk_data , y compris votre nltk_data , analyseur et corpus.

Si vous utilisez une version sans tête avec VPS, vous pouvez tout installer en exécutant Python et en procédant comme suit:

Importer Nltk
Nltk.download ()
d (à télécharger)
Tout (pour tout télécharger)

Cela téléchargera tout pour vous.

Maintenant que vous avez tout ce dont vous avez besoin, tapons quelques mots simples:

  • Corpus - Le corps du texte, singulier. Le corpus est son pluriel. Exemple: Une collection de revues médicales .
  • Lexique - vocabulaire et sa signification. Par exemple: dictionnaire anglais. Cependant, considérant qu'il existe différents thésaurus dans chaque domaine. Par exemple, pour les investisseurs financiers, le premier sens du mot Taureau est la personne qui a confiance dans le marché. Par rapport au «vocabulaire anglais commun», le premier sens du mot est animal. Par conséquent, les investisseurs financiers, les médecins, les enfants, les mécaniciens, etc. ont tous un vocabulaire spécial.
  • Jeton - Chaque “entité” fait partie d'une division basée sur des règles. Par exemple, lorsqu'une phrase est «scindée» en mots, chaque mot est une étiquette. Si vous divisez un paragraphe en phrases, chaque phrase peut également être un marqueur.

Ce sont les mots les plus fréquemment entendus lorsque vous entrez dans le champ de traitement du langage naturel (NLP), mais nous couvrirons plus de mots dans le temps. Voyons donc un exemple montrant comment scinder quelque chose en balises avec le module NLTK.

De nltk.tokenize import sent_tokenize, word_tokenize
EXAMPLE_TEXT = "Bonjour M. Smith, comment allez-vous aujourd'hui? Le temps est clément et Python est génial. Le ciel est bleu rosé. Vous ne devriez pas manger de carton."
Imprimer (sent_tokenize (EXAMPLE_TEXT))

Au début, vous pourriez penser que la segmentation des mots par mot ou par phrase est une affaire assez triviale. Pour de nombreuses phrases, cela peut être. La première étape pourrait consister à exécuter un simple .Divisé('. ') , ou par un point, suivi d'un espace fractionné. Ensuite, vous introduirez peut-être des expressions régulières, divisées par des points, des espaces, puis des lettres majuscules. Le problème est quelque chose comme M. Smith et il y a beaucoup d'autres choses qui vont vous causer des ennuis. La segmentation par mot est également un défi, en particulier lorsque vous envisagez des abréviations, telles que nous et étaient . NLTK vous fait gagner beaucoup de temps avec cette opération apparemment simple mais très compliquée.

Le code ci-dessus générera la phrase, divisée en une liste de phrases, vous pouvez utiliser le pour boucle à parcourir.

[ 'Hello Mr. Smith, how are you doing today?', 'The weather is great, and Python is awesome.', 'The sky is pinkish-blue.', "You shouldn't eat cardboard." ]

Donc ici nous créons les tags, ce sont toutes des phrases. Divisons les mots par mot cette fois.

Imprimer (word_tokenize (EXAMPLE_TEXT))
[ 'Hello' , 'Mr.' , 'Smith' , ',' , 'how' , 'are' , 'you ' , 'doing ' , 'today ' , '?' , 'The' , 'weather' , 'is' , 'great' , ',' , 'and' , 'Python' , 'is' , 'awesome ' , '.' , 'The' , 'sky' , 'is' , 'pinkish-blue' , '.' , 'You' , 'should' , "n't" , 'eat' , 'cardboard' , '.' ]

Il y a quelques choses à noter ici. Tout d'abord, notez que la ponctuation est traitée comme une balise séparée. Notez également que le mot ne devrait pas séparé en devrait et NT . La dernière chose à noter est que bleu rosé est en effet traité comme "un mot", qui est ce qu'il est. Cool!

Maintenant, en regardant les mots après ces participes, nous devons commencer à réfléchir à ce que pourrait être notre prochaine étape. Nous avons commencé à réfléchir à la manière d’obtenir le sens en observant ces mots. Nous pouvons réfléchir à la manière de valoriser de nombreux mots, mais nous voyons aussi des mots qui ne valent rien. C’est une forme de «mot d’arrêt» que nous pouvons également gérer. C'est ce que nous discuterons dans le prochain tutoriel.

II. NLTK et mots vides

Le traitement du langage naturel consiste à effectuer une analyse ou un traitement. La machine peut au moins comprendre le sens, la représentation ou la suggestion du texte dans une certaine mesure.

C'est évidemment un défi énorme, mais il y a des étapes que tout le monde peut suivre. Cependant, l’idée principale est que les ordinateurs ne comprennent pas les mots directement. C'est choquant que les humains ne le fassent pas. Chez l'homme, la mémoire est décomposée en signaux électriques dans le cerveau sous la forme d'un groupe de neurones qui émet des motifs. Il y a encore beaucoup de choses inconnues sur le cerveau, mais plus nous divisons le cerveau en éléments de base, plus nous en trouverons. Eh bien, il s'avère que les ordinateurs stockent les informations de manière très similaire! Si nous voulons imiter la façon dont les humains lisent et comprennent le texte, nous avons besoin d'un moyen aussi proche que possible. En général, les ordinateurs utilisent des chiffres pour tout représenter, mais nous voyons souvent l’utilisation de signaux binaires directement dans la programmation ( Vrai ou Faux , qui peut être converti directement en 1 ou 0, directement à partir de la présence d'un signal électrique (Vrai, 1) ou pas existé (Faux, 0) ). Pour ce faire, nous avons besoin d’un moyen de convertir les mots en modèles numériques ou en signaux. Convertir des données en quelque chose qu'un ordinateur peut comprendre s'appelle "prétraitement". L'une des principales formes de prétraitement consiste à filtrer les données inutiles. Dans le traitement du langage naturel, les mots inutiles (données) sont appelés mots vides.

Nous pouvons immédiatement réaliser que certains mots ont plus de signification que d’autres. Nous pouvons également voir que certains mots sont inutiles et sont des mots remplis. Par exemple, nous les utilisons en anglais pour compléter des phrases. Il n’existe donc pas de son aussi étrange. L’un des exemples les plus courants, non officiels et inutiles est le mot euh . Les gens utilisent souvent euh à remplir, plus que d'autres mots. Ce mot n'a de sens que si nous recherchons quelqu'un qui manque de confiance en soi, de confusion ou pas grand chose. Nous faisons tous cela, il y a ... oh ... plusieurs fois, vous pouvez m'entendre dire euh ou euh dans la vidéo. Pour la plupart des analyses, ces mots sont inutiles.

Nous ne voulons pas que ces mots prennent de la place dans notre base de données ou prennent un temps de traitement précieux. Par conséquent, nous appelons ces mots «mots inutiles», car ils sont inutiles et nous voulons les traiter. Une autre version du mot «mot d'arrêt» peut être écrite davantage: les mots auxquels nous nous arrêtons.

Par exemple, si vous trouvez des mots souvent utilisés pour satire, arrêtez-vous immédiatement. Les mots ou expressions satiriques varient en fonction du thésaurus et du corpus. Pour le moment, nous traiterons les mots vides comme des mots qui ne contiennent aucun sens et nous les supprimerons.

Vous pouvez le faire facilement en stockant une liste de mots que vous pensez être des mots vides. NLTK utilise un tas de mots qu'ils pensent être des mots vides pour vous aider à commencer, vous pouvez y accéder via le corpus NLTK:

De nltk.corpus importer des mots vides

Voici la liste:

>>> set (mots vides. mots ('anglais'))
{'nous-mêmes', 'le sien', 'entre', 'vous', 'mais', 'encore', 'là', 'environ', 'une fois', 'pendant', 'pendant', 'dehors', 'très', ' Avoir ',' avec ',' ils ',' posséder ',' un ',' être ',' quelques ',' pour ',' faire ',' son ',' votre ',' tel ',' tel ',' dans ' , 'of', 'most', 'lui-même', 'other', 'off', 'est', 's', 'am', 'ou', 'qui', 'comme', 'de', ' Lui ',' chacun ',' le ',' eux-mêmes ',' jusqu'à ',' ci-dessous ',' sommes ',' nous ',' ceux-ci ',' votre ',' son ',' par ',' par ' , 'ni', 'moi', 'étais', 'elle', 'plus', 'lui-même', 'ceci', 'bas', 'devrait', 'notre', 'notre', 'leur', 'alors', ' Au-dessus ',' les deux ',' le ',' à ',' le 'notre', 'avait', 'elle', 'tous', 'non', 'quand', 'à', 'n'importe', 'avant' , 'eux', 'mêmes', 'et', 'été', 'ont', 'dans', 'volonté', 'sur', 'fait', 'vous-mêmes', 'alors', 'que', ' Parce que ',' quoi ',' sur ',' pourquoi ',' donc ',' peut ',' a fait ',' pas ',' maintenant ',' sous ',' il ',' vous ',' elle-même ' , 'a', 'juste', 'où', 'aussi', 'seulement', 'moi-même', 'lequel', 'ces', ' ',' après ',' peu ',' qui ',' t ',' être ',' si ',' leur ',' mon ',' contre ',' un ',' par ',' faisant ', 'ça', 'comment', 'plus loin', 'était', 'ici', 'que'}

Voici comment utiliser le mots_arrêt collection pour supprimer les mots vides du texte:

De nltk.corpus importer des mots vides
De nltk.tokenize import word_tokenize
Example_sent = "Ceci est un exemple de phrase montrant le filtrage des mots vides."
Stop_words = set (stopwords.words ('anglais'))
Word_tokens = word_tokenize (exemple_sent)
Filtered_sentence = [w for w in word_tokens if not w in stop_words]
Filtered_sentence = []
Pour w dans word_tokens:
Si w pas dans stop_words:
Filtered_sentence.append (w)
Imprimer (word_tokens)
Imprimer (filtré_sentence)

Notre sortie est:

['This', 'is', 'a', 'sample', 'sentence', ',', 'showing', 'off', 'the', 'stop', 'words', 'filtration', ' .']
['This', 'sample', 'sentence', ',', 'showing', 'stop', 'words', 'filtration', '.']

Merci à notre base de données. Une autre forme de prétraitement des données est la méthode «stemming». Nous en discuterons ensuite.

III. Extraction de tige NLTK

Le concept de stemming est une approche standardisée. Outre le temps, de nombreuses variantes du mot ont la même signification.

La raison pour laquelle nous extrayons la tige est pour raccourcir la durée de la recherche et normaliser la phrase.

considérer:

Je faisais un tour dans la voiture.
Je montais dans la voiture.

Ces deux phrases signifient la même chose. dans la voiture (dans la voiture) est le même. je (I) est le même. Dans les deux cas, ing exprime clairement le passé, il est donc vraiment nécessaire de faire la distinction entre le fait d’essayer de comprendre le sens de cette activité de style passé. équitation et faire un tour ?

Non, pas

Ceci est juste un petit exemple, mais imaginez chaque mot en anglais qui puisse être placé sur tous les temps possibles et apposé sur le mot. Chaque version comporte un dictionnaire séparé qui sera très redondant et inefficace, d’autant plus qu’une fois que nous convertissons en nombres, la «valeur» sera la même.

L'un des algorithmes d'extraction de la porcelaine les plus populaires est Porter, qui existait en 1979.

Premièrement, nous devons explorer et définir nos racines:

À partir de nltk.stem import PorterStemmer
De nltk.tokenize import sent_tokenize, word_tokenize
Ps = PorterStemmer ()

Maintenant, choisissons des mots avec des racines similaires, par exemple:

Example_words = [ "python" , "pythoner" , "pythoning" , "pythoned" , "pythonly" ]

Ci-dessous, nous pouvons le faire pour extraire facilement les tiges:

Pour w dans example_words:
Imprimer (ps.stem (w))

Notre sortie:

Python
Python
Python
Python
Pythonli

Essayons maintenant d’extraire d’une phrase typique au lieu de quelques mots:

New_text = "Il est important de très pythonly quand vous pythonez avec python. Tous les pythoners ont mal pythoné au moins une fois."
Words = word_tokenize (new_text)
Pour w en mots:
Imprimer (ps.stem (w))

Nos résultats sont maintenant:

Il
Est
Importation
À
Par
Veri
Pythonli
Tandis que
Vous
Sont
Python
Avec
Python
.
Tout
Python
Avoir
Python
Poorli
À
Moins
Onc
.

Nous aborderons ensuite le contenu plus avancé du module NLTK, le balisage partiel du discours, dans lequel nous pouvons utiliser le module NLTK pour identifier la partie du discours de chaque mot de la phrase.

IV Marquage partiel de la parole par NLTK

Un aspect plus puissant du module NLTK est qu’il peut être utilisé pour le balisage d’une partie de la parole. Cela signifie que les mots d'une phrase doivent être marqués comme des noms, des adjectifs, des verbes, etc. Ce qui est encore plus impressionnant, c'est qu'il peut aussi être marqué par le temps, entre autres. Voici une liste de balises, leur signification et quelques exemples:

Liste de balises POS:
  Conjonction de coordination du CC
CD cardinal digit
DT déterminant
EX existentielle là-bas (comme: "il y a" ... pensez-y comme "il existe")
Mot étranger FW
Conjonction IN préposition / subordination
JJ adjectif 'grand'
Adjectif JJR, comparatif 'plus grand'
Adjectif JJS, superlatif 'plus grand'
Marqueur de liste LS 1)
MD modal pourrait, sera
NN nom, singulier 'bureau'
NNS nom pluriel 'bureaux'
NNP nom propre, singulier 'Harrison'
NNPS nom propre, pluriel 'Américains'
PDT prédéterminé 'tous les enfants'
POS terminal possessif parent
PRP, pronom personnel I, il, elle
PRP $ pronom possessif mon, son, le sien
RB adverbe très, silencieusement,
Adverbe RBR, meilleur comparatif
Adverbe RBS, meilleur superlatif
RP particule abandonner
À aller 'au' magasin.
UH interjection errrrrrrrm
Verbe VB, forme de base prendre
VBD verbe, le passé a pris
Verbe VBG, gérondif / Participe présent prenant
VBN verbe, participe passé pris
Verbe VBP, chanter. prenne, non 3 jours
VBZ, 3 ème personne chante. le présent prend
WDT wh-determiner qui
WP wh-pronom qui, quoi
WP $ possessif wh-pronom dont
WRB wh-abverb où, quand

Comment utilisons-nous cela? Lorsque nous nous en occupons, nous devons expliquer un nouveau marqueur de phrase appelé PunktSentenceTokenizer . Ce marqueur permet l'apprentissage automatique non supervisé, vous permettant ainsi de vous entraîner sur n'importe quel texte que vous utilisez. Premièrement, obtenons quelques importations que nous prévoyons d’utiliser:

Importer Nltk
De nltk.corpus import state_union
De nltk.tokenize, importez PunktSentenceTokenizer

Créons maintenant les données de formation et de test:

Train_text = state_union.raw ("2005-GWBush.txt")
Sample_text = state_union.raw ("2006-GWBush.txt")

L’un est le discours sur l’état de l’Union depuis 2005 et l’autre, le discours du président George W. Bush depuis 2006.

Ensuite, nous pouvons former le marqueur Punkt comme suit:

Custom_sent_tokenizer = PunktSentenceTokenizer (train_text)

Après cela, nous pouvons réellement diviser le mot et utiliser:

Tokenized = custom_sent_tokenizer.tokenize (sample_text)

Nous pouvons maintenant terminer le script de marquage d'une partie du discours en créant une fonction qui traverse et marque la partie du discours de chaque phrase comme suit:

Def process_content ():
Essayez:
Pour i en tokenized[: 5 ]:
Mots = nltk.word_tokenize (i)
Tagged = nltk.pos_tag (mots)
Imprimer (étiqueté)
      Sauf exception comme e:
Imprimer (str (e))
Process_content ()

La sortie doit être une liste de tuple, le premier élément du tuple étant un mot et le second élément faisant partie de la balise speech. Cela devrait ressembler à:

[('PRESIDENT', 'NNP'), ('GEORGE', 'NNP'), ('W.', 'NNP'), ('BUSH', 'NNP'), ( "'S" , 'POS '), ('ADDRESS', 'NNP'), ('BEFORE', 'NNP'), ('A', 'NNP'), ('JOINT', 'NNP'), ('SESSION', 'NNP '), ('OF', 'NNP'), ('THE', 'NNP'), ('CONGRESS', 'NNP'), ('ON', 'NNP'), ('THE', 'NNP '), ('STATE', 'NNP'), ('OF', 'NNP'), ('THE', 'NNP'), ('UNION', 'NNP'), ('January', 'NNP '), (' 31 ', 'CD'), (',', ','), (' 2006 ', 'CD'), ('THE', 'DT'), ('PRESIDENT', 'NNP '), (':', ':'), ('Thank', 'NNP'), ('you', 'PRP'), ('all', 'DT'), ('.', '. ')] [('Mr.', 'NNP'), ('Speaker', 'NNP'), (',', ','), ('Vice', 'NNP'), ('President', 'NNP'), ('Cheney', 'NNP'), (',', ','), ('members', 'NNS'), ('of', 'IN'), ('Congress', 'NNP'), (',', ','), ('members', 'NNS'), ('of', 'IN'), ('the', 'DT'), ('Supreme', 'NNP'), ('Court', 'NNP'), ('and', 'CC'), ('diplomatic', 'JJ'), ('corps', 'NNS'), (',', ','), ('distinguished', 'VBD'), ('guests', 'NNS'), (',', ','), ('and', 'CC'), ('fellow', 'JJ'), ('citizens', 'NNS'), (':', ':'), ('Today', 'NN'), ('our', 'PRP  $'), ('nation', 'NN'), ('lost', 'VBD'), ('a', 'DT'), ('beloved', 'VBN'), (',', ' ,'), ('graceful', 'JJ'), (',', ','), ('courageous', 'JJ'), ('woman', 'NN'), ('who', ' WP'), ('called', 'VBN'), ('America', 'NNP'), ('to', 'TO'), ('its', 'PRP$'), ('founding', 'NN'), ('ideals', 'NNS'), ('and', 'CC'), ('carried', 'VBD'), ('on', 'IN'), ('a', 'DT'), ('noble', 'JJ'), ('dream', 'NN'), ('.', '.')] [('Tonight', 'NNP'), ('we' , 'PRP'), ('are', 'VBP'), ('comforted', 'VBN'), ('by', 'IN'), ('the', 'DT'), ('hope' , 'NN'), ('of', 'IN'), ('a', 'DT'), ('glad', 'NN'), ('reunion', 'NN'), ('with' , 'IN'), ('the', 'DT'), ('husband', 'NN'), ('who', 'WP'), ('was', 'VBD'), ('taken' , 'VBN'), ('so', 'RB'), ('long', 'RB'), ('ago', 'RB'), (',', ','), ('and' , 'CC'), ('we', 'PRP'), ('are', 'VBP'), ('grateful', 'JJ'), ('for', 'IN'), ('the' , 'DT'), ('good', 'NN'), ('life', 'NN'), ('of', 'IN'), ('Coretta', 'NNP'), ('Scott' , 'NNP'), ('King', 'NNP'), ('.', '.')] [('(', 'NN'), ('Applause', 'NNP'), ('. ', '.'), (')', ':')] [('Pres  Ident', 'NNP'), ('George', 'NNP'), ('W.', 'NNP'), ('Bush', 'NNP'), ('reacts', 'VBZ'), ( 'to', 'TO'), ('applause', 'VB'), ('during', 'IN'), ('his', 'PRP$'), ('State', 'NNP'), ('of', 'IN'), ('the', 'DT'), ('Union', 'NNP'), ('Address', 'NNP'), ('at', 'IN'), ('the', 'DT'), ('Capitol', 'NNP'), (',', ','), ('Tuesday', 'NNP'), (',', ','), ('Jan', 'NNP'), ('.', '.')]

Lorsque nous arriverons ici, nous pourrons commencer à comprendre, mais il reste encore du travail à faire. Le prochain sujet que nous aborderons est la segmentation, où nous suivons la partie du mot et divisons les mots en groupes significatifs.

V. bloc NLTK

Maintenant que nous connaissons la partie du discours, nous pouvons prêter attention au bloc, qui divise le mot en blocs significatifs. L'un des principaux objectifs du blocage est de regrouper ce que l'on appelle des «phrases nominales». Ce sont des phrases qui contiennent un ou plusieurs mots d'un nom, qui peuvent être des mots descriptifs, un verbe ou un adverbe. L'idée est de combiner des noms et des mots qui leur sont liés.

Pour bloquer, nous combinons l’étiquette de partie de parole avec une expression régulière. Principalement à partir d'expressions régulières, nous voulons tirer parti de ces choses:

+ = match 1 ou plus
? = correspond à 0 ou 1 répétitions.
* = correspondance 0 ou PLUS répétitions
. = N'importe quel caractère sauf une nouvelle ligne

Si vous avez besoin d’aide pour les expressions régulières, consultez le didacticiel lié ci-dessus. La dernière chose à noter est que le mot tag est représenté par < et > . Nous pouvons également placer une expression régulière dans la balise elle-même pour exprimer "tous les noms" ( ).

Importer Nltk
De nltk.corpus import state_union
De nltk.tokenize, importez PunktSentenceTokenizer
Train_text = state_union.raw ("2005-GWBush.txt")
Sample_text = state_union.raw ("2006-GWBush.txt")
Custom_sent_tokenizer = PunktSentenceTokenizer (train_text)
Tokenized = custom_sent_tokenizer.tokenize (sample_text)
Def process_content ():
Essayez:
Pour i tokenized:
Mots = nltk.word_tokenize (i)
Tagged = nltk.pos_tag (mots)
chunkGram = r "" "Chunk: {**+?} "" "
chunkParser = nltk.RegexpParser (chunkGram)
Chunked = chunkParser.parse (tagué)
Chunked.draw ()
        Sauf exception comme e:
Imprimer (str (e))
  Process_content ()
0*ilfwrPNbRjkwuDJ1 - NLTK - SWAYAM MITTAL - Moyenne

La ligne principale ici est:

chunkGram = r "" "Chunk: {**+?} "" "

Séparez cette ligne:

* : Zéro ou plusieurs adverbes de tout temps, suivis de:

* : Zéro ou plusieurs verbes de tout temps, suivis de:

+ : Un ou plusieurs noms raisonnables, suivis de:

? : Zéro ou un nom singulier.

Essayez un mélange amusant pour regrouper les différentes instances jusqu'à ce que vous vous sentiez familier.

Non couvert dans la vidéo, mais il existe également une tâche raisonnable pour accéder réellement à un bloc spécifique. Ceci est rarement mentionné, mais selon ce que vous faites, cela peut être une étape importante. Supposons que vous imprimiez le bloc et que vous voyiez le résultat suivant:

(S (PD (Président) / NNP GEORGE / NNP W./NNP BUSH / NNP)) 'S / POS (Adresse de chunk / NNP AVANT / NNP A / NNP SESSION / NNP DE / NNP A / NNP LE / NNP CONGRES / NNP ON / NNP THE / NNP STATE / NNP OF / NNP THE / NNP UNION / NNP janvier / NNP) 31 / CD, /, 2006 / CD THE / DT (Chunk PRESIDENT / NNP): /: (Chunk Merci / NNP) vous / PRP Tous / DT ./.)

Cool, cela nous aide à visualiser, mais que faire si nous voulons accéder à ces données via notre programme? Donc, ce qui se passe ici, c'est que notre variable «bloquante» est un arbre NLTK. Chaque "bloc" et "non-bloc" est la "sous-arborescence" de l'arbre. Nous pouvons nous y référer par quelque chose comme chunked.subtrees . Ensuite, nous pouvons parcourir ces sous-arbres comme ceci:

Pour le sous-arbre dans chunked.subtrees ():
Imprimer (sous-arbre)

Ensuite, nous pouvons uniquement nous préoccuper d’obtenir ces blocages et d’ignorer le reste. Nous pouvons utiliser le filtre paramètre dans le chunked.subtrees () appel.

Pour les sous-arbres dans chunked.subtrees (filter = lambda t: t.label () == 'Chunk')):
Imprimer (sous-arbre)

Nous effectuons maintenant un filtrage pour afficher la sous-arborescence avec l’étiquette «Block». Gardez à l'esprit que ce n'est pas un "bloc" dans l'attribut de bloc NLTK ... c'est un "bloc" littéral car c'est l'étiquette que nous lui avons donnée: chunkGram = r "" "Chunk: {**+?} "" " .

Si nous écrivons quelque chose comme chunkGram = r "" "Pythons: {**+?} "" " alors on peut passer "Pythons." Tags à filtrer. Le résultat devrait être comme ceci:

- (Président de groupe / NNP GEORGE / NNP W. / NNP BUSH / NNP) (Adresse de groupe / NNP AVANT / NNP A / NNP JOINT / NNP SESSION / NNP OF / NNP LE / CONGRES NNP / NNP ON / NNP LE / NNP THE / NNP THE / NNP THE / NNP OF / NNP THE / NNP UNION / NNP janvier / NNP) (Chunk PRESIDENT / NNP) (Chunk Thank / NNP)

Le code complet est:

Importer Nltk
De nltk.corpus import state_union
De nltk.tokenize, importez PunktSentenceTokenizer
Train_text = state_union.raw ("2005-GWBush.txt")
Sample_text = state_union.raw ("2006-GWBush.txt")
Custom_sent_tokenizer = PunktSentenceTokenizer (train_text)
Tokenized = custom_sent_tokenizer.tokenize (sample_text)
Def process_content ():
Essayez:
Pour i tokenized:
Mots = nltk.word_tokenize (i)
Tagged = nltk.pos_tag (mots)
chunkGram = r "" "Chunk: {**+?} "" "
chunkParser = nltk.RegexpParser (chunkGram)
Chunked = chunkParser.parse (tagué)
                        Imprimer (en bloc)
Pour les sous-arbres dans chunked.subtrees (filter = lambda t: t.label () == 'Chunk')):
Imprimer (sous-arbre)
                        Chunked.draw ()
        Sauf exception comme e:
Imprimer (str (e))
Process_content ()

VI. NLTK ajoute un écart (Chinking)

Vous constaterez peut-être qu’après plusieurs blocages, vous ne voulez pas utiliser certains mots dans votre bloc, mais vous ne savez pas comment vous en débarrasser en les bloquant. Vous constaterez peut-être que l’ajout d’un écart est votre solution.

Ajouter un espace est similaire à un bloc, ce qui est fondamentalement un moyen de supprimer un bloc d'un bloc. Le bloc que vous avez retiré du bloc est votre espace.

Le code est très similaire, il vous suffit d'utiliser } { pour coder l'écart, derrière le bloc, pas le {} bloc.

Importer Nltk
De nltk.corpus import state_union
De nltk.tokenize, importez PunktSentenceTokenizer
Train_text = state_union.raw ("2005-GWBush.txt")
Sample_text = state_union.raw ("2006-GWBush.txt")
Custom_sent_tokenizer = PunktSentenceTokenizer (train_text)
Tokenized = custom_sent_tokenizer.tokenize (sample_text)
Def process_content ():
Essayez:
Pour i en tokenized[ 5 :]:
Mots = nltk.word_tokenize (i)
Tagged = nltk.pos_tag (mots)
                        chunkGram = r "" "Chunk: {<.>+}}+ {"" "
                        chunkParser = nltk.RegexpParser (chunkGram)
Chunked = chunkParser.parse (tagué)
                        Chunked.draw ()
        Sauf exception comme e:
Imprimer (str (e))
Process_content ()
0*4S8Tht6BakAT8gcb - NLTK - SWAYAM MITTAL - Moyenne

Maintenant, la principale différence est la suivante:

}+ {

Cela signifie que nous voulons supprimer un ou plusieurs verbes, prépositions, qualificatifs ou à mots de l'écart.

Maintenant que nous avons appris à réaliser un partitionnement personnalisé et à ajouter des espaces, examinons le formulaire de blocage fourni avec NLTK, la reconnaissance d’entité nommée.

VII. Reconnaissance d'entité nommée NLTK

L'une des formes les plus importantes de blocage dans le traitement du langage naturel est appelée «reconnaissance d'entité nommée». L'idée est de laisser la machine extraire immédiatement des «entités» telles que des personnes, des lieux, des objets, des localisations, des devises, etc.

Cela peut être un défi, mais NLTK est construit pour nous. La reconnaissance d’entité nommée de NLTK a deux options principales: identifier toutes les entités nommées ou identifier les entités nommées en tant que leurs types respectifs, tels que personne, emplacement, emplacement, etc.

Ceci est un exemple:

Importer Nltk
De nltk.corpus import state_union
De nltk.tokenize, importez PunktSentenceTokenizer
Train_text = state_union.raw ("2005-GWBush.txt")
Sample_text = state_union.raw ("2006-GWBush.txt")
Custom_sent_tokenizer = PunktSentenceTokenizer (train_text)
Tokenized = custom_sent_tokenizer.tokenize (sample_text)
Def process_content ():
Essayez:
Pour i en tokenized[ 5 :]:
Mots = nltk.word_tokenize (i)
Tagged = nltk.pos_tag (mots)
namedEnt = nltk.ne_chunk (tagged, binary = True)
namedEnt.draw ()
Sauf exception comme e:
Imprimer (str (e))
Process_content ()

Vous pouvez voir quelque chose tout de suite. Quand binaire est faux, il choisit aussi la même chose, mais casse le terme maison Blanche dans blanc et Maison comme s'ils étaient différents, et on peut le voir dans l'option binaire = vrai , entité nommée L'identification dit que maison Blanche fait partie de la même entité nommée, ce qui est correct.

Selon votre objectif, vous pouvez utiliser le binaire option. Si ton binaire est faux , voici ce que vous pouvez obtenir, le type d’entité nommée:

Type de NE et exemples
ORGANISATION - Géorgie - Pacifique Corp. , QUI
PERSONNE - Eddy Bonte, président Obama
EMPLACEMENT - Murray River, mont Everest
DATE - juin 2008 - 06 - 29
HEURE - deux heures cinquante, 13 h 30. m.
ARGENT - 175 millions de dollars canadiens, 10,40 GBP
POURCENTAGE - vingt pour cent, 18,75%
INSTALLATION - Monument de Washington, Stonehenge
GPE - Asie du Sud-Est, Midlothian

Quoi qu'il en soit, vous constaterez peut-être que vous devez faire plus de travail pour bien faire les choses, mais cette fonctionnalité est très puissante.

Dans le prochain tutoriel, nous aborderons quelque chose de similaire à l'extraction de tige, appelée «lemmatiser».

VIII. Restauration morphologique NLTK

Une opération qui ressemble beaucoup à la tige est appelée restauration morphologique. La principale différence entre les deux réside dans le fait que, comme vous l’avez déjà vu, les pouvoirs d’équation créent souvent des mots qui n'existent pas, alors que les formes verbales sont de véritables mots.

Ainsi, votre tige, c'est-à-dire le mot avec lequel vous vous retrouvez, n'est pas quelque chose que vous pouvez rechercher dans le dictionnaire, mais vous pouvez trouver une forme de mot.

Parfois, vous vous retrouvez avec des mots très similaires, mais parfois, vous obtenez des mots complètement différents. Regardons quelques exemples.

De nltk.stem importer WordNetLemmatizer
Lemmatizer = WordNetLemmatizer ()
  Imprimer (lemmatizer.lemmatize ("chats"))
Imprimer (lemmatizer.lemmatize ("cactus"))
Imprimer (lemmatizer.lemmatize ("oies"))
Print (lemmatizer.lemmatize ("roches"))
Print (lemmatizer.lemmatize ("python"))
Print (lemmatizer.lemmatize ("mieux", pos = "a"))
Print (lemmatizer.lemmatize ("meilleur", pos = "a"))
Print (lemmatizer.lemmatize ("run"))
Print (lemmatizer.lemmatize ("run", 'v'))

Nous avons ici quelques exemples de la forme du mot que nous utilisons. La seule chose à noter est que lemmatiser accepte le paramètre de partie du discours pos . Si non fourni, la valeur par défaut est "nom". Cela signifie qu'il essaiera de trouver le nom le plus proche, ce qui peut vous causer des ennuis. Si vous utilisez une restauration morphologique, n'oubliez pas!

Dans le prochain tutoriel, nous allons plonger dans le corpus NTLK fourni avec le module pour voir toute la documentation de qualité, et ils nous y attendent.

IX. Corpus NLTK

Dans cette partie du tutoriel, je veux prendre un moment pour plonger dans le corpus que nous avons téléchargé! Le corpus NLTK est une collection de données en langage naturel qui mérite d'être examinée.

Presque tous les fichiers du corpus NLTK suivent les mêmes règles, y accédant à l’aide du module NLTK, mais ils n’ont rien de magique. La plupart de ces fichiers sont des fichiers de texte brut, dont certains sont des fichiers XML, d'autres sont des fichiers de format, mais peuvent être consultés manuellement ou dans des modules et en Python. Parlons de les visualiser manuellement.

En fonction de votre installation, votre nltk_data Le répertoire peut être caché à plusieurs endroits. Pour savoir où il se trouve, accédez à votre répertoire Python, où se trouve le module NLTK. Si vous ne savez pas où, utilisez le code suivant:

Importer Nltk
Imprimer (nltk. __File__)

Exécutez-le et la sortie sera l'emplacement du module NLTK __init__.py . data.py dans le répertoire NLTK et recherchez le data.py fichier.

La partie importante du code est:

Si sys.platform.startswith ('win'):
# Emplacements communs sous Windows:
Chemin + =[[
Str (r'C: nltk_data '), str (r'D: nltk_data'), str (r'E: nltk_data '),
Os.path.join (sys.prefix, str ('nltk_data')),
Os.path.join (sys.prefix, str ('lib'), str ('nltk_data')),
Os.path.join (os.environ.get (str ('APPDATA'), str ('C: \')), str ('nltk_data'))
]
Autre :
# Emplacements communs sous UNIX et OS X:
Chemin + =[[
Str ('/ usr / share / nltk_data'),
Str ('/ usr / local / share / nltk_data'),
Str ('/ usr / lib / nltk_data'),
Str ('/ usr / local / lib / nltk_data')
]

Là, vous pouvez voir les différents répertoires possibles pour nltk_data . Si vous êtes sur Windows, c'est probablement dans votre données d'application , dans un répertoire local. Pour ce faire, vous devez ouvrir votre navigateur de fichiers, aller au début et taper %données d'application% .

Cliquez ensuite sur roaming et trouver le nltk_data annuaire. Vous y trouverez votre fichier de corpus. Le chemin complet est comme ça:

C:  Utilisateurs  swayam.mittal  AppData  Roaming  nltk _data  corpora

Ici vous avez tous les corpus disponibles, y compris les livres, les chats, les critiques de films et plus

Nous allons maintenant discuter de l’accès à ces documents via NLTK. Comme vous pouvez le constater, il s’agit principalement de documents texte. Vous pouvez donc ouvrir et lire des documents à l’aide de code Python. Cela dit, le module NLTK dispose de plusieurs méthodes pratiques pour gérer le corpus. Vous constaterez peut-être que leur utilisation est pratique. Voici un exemple de la façon dont nous avons ouvert la Bible de Gutenberg et lu les premières lignes:

Depuis nltk.tokenize, importez sent_tokenize, PunktSentenceTokenizer
De nltk.corpus import gutenberg
# exemple de texte
Sample = gutenberg.raw ("bible-kjv.txt")
Tok = sent_tokenize (exemple)
Pour x dans l'intervalle (5):
Imprimer (tok[x])

L’un des ensembles de données les plus avancés est wordnet . Wordnet est un ensemble de mots, définitions, exemples d'utilisation, synonymes, antonymes, etc. Nous utiliserons ensuite wordnet en profondeur.

X. NLTK et Wordnet

WordNet est une base de données de vocabulaire anglais créée par Princeton et faisant partie du corpus NLTK.

Vous pouvez utiliser les modules WordNet et NLTK ensemble pour rechercher des significations de mots, des synonymes, des antonymes et plus encore. Introduisons quelques exemples.

Tout d'abord, vous devrez importer wordnet :

De nltk.corpus import wordnet

Ensuite, nous prévoyons d'utiliser le mot programme trouver des synonymes:

Syns = wordnet.synsets ("programme")

Un exemple de synonyme:

Imprimer (syns[ 0 ].prénom())
# plan.n.01

Juste le mot:

Imprimer (syns[ 0 ] .lemmas ()[ 0 ] .prénom ())
# plan

La définition du premier synonyme:

Imprimer (syns[ 0 ].définition())
# une série d'étapes à accomplir ou d'objectifs à accomplir

Exemple d'utilisation de mots:

Imprimer (syns[ 0 ].exemples())
# [ 'they drew up a six-step plan', 'they discussed plans for a new bond issue']

Ensuite, comment identifier les synonymes et les antonymes d'un mot? Ces formes sont synonymes et vous pouvez ensuite utiliser .antonymes trouver l'antonyme de la forme. Nous pouvons donc renseigner des listes telles que:

Synonymes = []
Antonymes = []
Pour syn in wordnet.synsets ("bon"):
Pour l in syn.lemmas ():
Synonyms.append (l.name ())
Si l.antonymes ():
Antonyms.append (l.antonymes ()[ 0 ].prénom())
  Imprimer (définir (synonymes))
Imprimer (set (antonymes))
  '' '{' bénéfique ',' juste ',' vertical ',' à fond ',' in _force ',' bien ',' habile ',' habile ',' sonore ',' intact ',' expert ',' Compétent ',' in _effect ',' honorable ',' adepte ',' sécurisé ',' marchandise ',' estimable ',' sainement ',' correct ',' correct ',' bon ',' sérieux ',' mûr ',' salutaire ',' cher ',' pratiqué ',' bonté ',' sans danger ',' efficace ',' intact ',' fiable ',' non décomposé ',' honnête ',' complet ',' proche ', 'trade_good'} {'méchant', 'méchant', 'mauvais', 'méchant', 'malade'} '' '

Comme vous pouvez le constater, notre synonyme est plus qu’un antonyme, car nous ne cherchons que l’antonyme de la première forme, mais vous pouvez facilement équilibrer cela en effectuant exactement le même processus pour le mot. mal .

Ensuite, nous pouvons facilement utiliser WordNet pour comparer les similitudes de deux mots et de leurs temps, et combiner les méthodes Wu et Palmer pour la pertinence sémantique.

Comparons les noms navireet bateau:

W1 = wordnet.synset ('ship.n.01')
W2 = wordnet.synset ('boat.n.01')
print (w1.wup_similarity (w2))
# 0.9090909090909091
W1 = wordnet.synset ('ship.n.01')
W2 = wordnet.synset ('car.n.01')
print (w1.wup_similarity (w2))
# 0.6956521739130435
W1 = wordnet.synset ('ship.n.01')
W2 = wordnet.synset ('cat.n.01')
print (w1.wup_similarity (w2))
# 0.38095238095238093

Ensuite, nous allons discuter de certaines questions et commencer à discuter du sujet de la catégorisation de texte.

XI. Classification du texte NLTK

Maintenant que nous connaissons NLTK, essayons de traiter la catégorisation du texte. L'objectif de la catégorisation du texte peut être assez large. Peut-être essayons-nous de classer le texte en politique ou militaire. Peut-être que nous essayons de classer par le genre de l'auteur. Une tâche de catégorisation de texte assez répandue consiste à identifier le corps du texte en tant que courrier indésirable ou non courrier indésirable, tel qu'un filtre de courrier électronique. Dans notre cas, nous allons essayer de créer un algorithme d'analyse de sentiment.

Pour ce faire, nous essayons d’abord d’utiliser une base de données de critiques de films appartenant au corpus NLTK. À partir de là, nous essaierons d'utiliser le vocabulaire comme «fonctionnalité», qui fait partie d'une critique de film «positive» ou «négative». Le corpus NLTK critiques de filmsensemble de données a des commentaires et ils sont marqués comme positif ou négatif. Cela signifie que nous pouvons former et tester ces données. Premièrement, pré-traitons nos données.

Importer Nltk
importer au hasard
depuis nltk.corpus import movie_reviews
Documents =[(list(movie_reviewswords(fileid))category)[(list(movie_reviewswords(fileid))category)
For category in movie_reviews.categories()
for fileid in movie_reviews.fileids(category)]
Random.shuffle(documents)
Print(documents[ 1 ])
All_words = []
For w in movie_reviews.words():
All_words.append(w.lower())
All_words = nltk.FreqDist(all_words)
Print(all_words.most_common( 15 ))
Print(all_words[ "stupid" ])

It may take some time to run this script because the movie review dataset is a bit large. Let us introduce what happened here.

After importing the data set we want, you will see:

Documents =[(list(movie_reviewswords(fileid))category)[(list(movie_reviewswords(fileid))category)
for category in movie_reviews.categories()
for fileid in movie_reviews.fileids(category)]

Basically, in simple English, the above code is translated into: in each category (we have forward and exclusive), select all file IDs (each comment has its own ID), then store the word_tokenizedversion for the file ID (word list) followed by a positive or negative label in a large list.

Next, we use randomto disrupt our files. This is because we are going to train and test. If we order them in order, we may train all negative comments, and some positive comments, and then test on all positive comments. We don't want this, so we messed up the data.

Then, in order for you to see the data you are using, we print out documents[1]that this is a large list where the first element is a list of words and the second element is posou neglabel.

Next, we want to collect all the words we found, so we can have a huge list of typical words. From here, we can perform a frequency distribution and then find the most common words. As you can see, the most popular “words” are actually punctuation, la, uneetc., but soon we will get valid vocabulary. We are going to store thousands of the most popular words, so this shouldn't be a problem.

Print(all_words. most_common( 15 ) )

The 15 most commonly used words are given above. You can also find out the number of occurrences of a word by following the steps below:

Print  (all_words[ "stupid" ])

Next, we begin to store our words as features of positive or negative movie reviews.

XII. use NLTK to convert words into features

In this tutorial, we build on previous videos and compile a list of features for words in positive and negative comments to see trends in specific types of words in positive or negative comments.

Initially, our code:

Import nltk
Import random
from nltk.corpus import movie_reviews
Documents =[(list(movie_reviewswords(fileid))category)[(list(movie_reviewswords(fileid))category)
for category in movie_reviews.categories()
for fileid in movie_reviews.fileids(category)]
Random .shuffle(documents)
All_words = []
For w in movie_reviews. words ():
All_words.append(w. lower ())
All_words = nltk.FreqDist(all_words)
Word_features = list(all_words. keys ())[: 3000 ]

Almost as before, just now there is a new variable that word_featurescontains the top 3000 most commonly used words. Next, we'll build a simple function that finds these top 3000 words in our positive and negative documents, marking their presence as yes or no:

Def  find_features  (document) :
Words = set(document)
Features = {}
For w in word_features:
Caractéristiques[w] = (w in words)
        Return features

Below, we can print out the feature set:

Print(( find_features(movie_reviews. words( 'neg/cv000_29416.txt' ) ) ) ) )

We can then do this for all of our documentation by saving the feature boolean values ​​and their respective positive or negative categories by doing the following:

Featuresets = [(find_features(rev), category) for (rev, category) in documents]

Awesome, now we have features and tags, what’s next? Usually, the next step is to continue and train the algorithm and then test it. So let’s continue to do this, starting with the naive Bayes classifier in the next tutorial!

XIII. NLTK Naive Bayes Classifier

It’s time to choose an algorithm that divides our data into training and test sets and then starts! The algorithm we first use is the naive Bayes classifier. This is a very popular text categorization algorithm, so we can only try it first. However, before we can train and test our algorithm, we need to first break the data into a training set and a test set.

You can train and test the same data set, but this will give you some serious deviations, so you shouldn’t train and test the exact same data. For this reason, since we have disrupted the data set, we will first use 1900 out-of-order comments with positive and negative comments as the training set. Then we can test on the last 100 to see how accurate we are.

This is called supervised machine learning because we are presenting data to the machine and telling it “this data is positive” or “this data is negative.” Then, after the training is complete, we show the machine some new data and ask the computer what we think of the new data based on what we have taught before.

We can split the data in the following ways:

# set that we'll train our classifier with 
training_ set = featuresets[: 1900 ]
# set that we'll test against. 
testing_ set = featuresets[ 1900 :]

Below, we can define and train our classifiers:

Classifier = nltk .NaiveBayesClassifier  .train (training_set)

First, we simply call the naive Bayes classifier and use it in a row .train()for training.

It’s simple enough, now it’s trained. Next, we can test it:

Print ( "Classifier accuracy percent:" ,(nltk.classify.accuracy(classifier, testing_set)) *100 )

Hey, you got your answer. If you missed it, the reason we can “test” the data is that we still have the right answer. So, in the test, we present the data to the computer without providing the correct answer. If it correctly guesses what we know, then the computer is correct. Considering the disruption we’ve done, you and I may be different in accuracy, but you should see an average of 60–75% accuracy.

Next, we can learn more about the most valuable words in positive or negative comments:

classifier the .Show _most_informative_features ( 15 )

This is different for everyone, but you should see something like this:

Most Informative Features
Insulting = True neg : pos = 10.6 : 1.0
ludicrous = True neg : pos = 10.1 : 1.0
winslet = True pos : neg = 9.0 : 1.0
detract = True pos : neg = 8.4 : 1.0
breathtaking = True pos : neg = 8.1 : 1.0
Silverstone = True neg : pos = 7.6 : 1.0
excruciatingly = True neg : pos = 7.6 : 1.0
warns =True pos : neg = 7.0 : 1.0
tracy = True pos : neg = 7.0 : 1.0
insipid = True neg : pos = 7.0 : 1.0
freddie = True neg : pos = 7.0 : 1.0
damon = True pos : neg = 5.9 : 1.0
debate = True pos : neg = 5.9 : 1.0
ordered = True pos : neg = 5.8 : 1.0
lang = True pos : neg = 5.7: 1.0

What this tells you is that each word’s negative to positive appearance, or vice versa. So here we can see that the insultingword in the negative comment appears 10.6 times more than the positive comment. LudicrousIt is 10.1.

Now let’s assume that you are completely satisfied with your results, that you want to continue, and perhaps use this classifier to predict what is going on. It is very impractical to train the classifier and retrain it whenever you need to use the classifier. Therefore, you can use the cornichonmodule to save the classifier. We will do it next.

XIV. Save the classifier with NLTK

Training classifiers and machine learning algorithms can take a long time, especially if you train on a larger data set. Ours is actually very small. Can you imagine that you have to train the classifier every time you want to start using the classifier? So horrible! Instead, we can use the cornichonmodule and serialize our classifier object so that all we have to do is simply load the file.

So what should we do? The first step is to save the object. To do this, you first need to import at the top of the script cornichon, and then after .train()training with the classifier, you can call the following lines:

Save_classifier = open ( "naivebayes.pickle" , "wb" )
Pickle. dump (classifier, save_classifier)
Save_classifier. close ()

This opens a cornichonfile and is ready to write some data in bytes. Then we use pickle.dump()to dump the data. pickle.dump()The first argument is what you write, and the second argument is where you write it.

After that, we closed the file as we requested, which means that we now have a cornichonserialized object in the script's directory !

Next, how do we start using this classifier? .pickleFiles are serialized objects, all we need to do now is to read them into memory, which is as simple as reading any other normal file. this way:

Classifier_f = open ( "naivebayes.pickle" , "rb" )
Classifier = pickle. load (classifier_f)
Classifier_f. close ()

Here we have performed a very similar process. We open the file to read the bytes. Then we use pickle.load()to load the file and save the data to the classifier variable. Then we close the file, that's it. We now have the same classifier object as before!

Now we can use this object, and whenever we want to use it for classification, we no longer need to train our classifier.

Although it’s all good, we may not be happy with the 60–75% accuracy we get. What about other classifiers? In fact, there are many classifiers, but we need the scikit-learn (sklearn) module. Fortunately, NLTK employees recognized the value of incorporating the sklearn module into NLTK, and they built a small API for us. This is what we will do in the next tutorial.

XV. NLTK and Sklearn

Now we have seen how easy it is to use a classifier, now we want to try more! The best module for Python is the Scikit-learn (sklearn) module.

If you want to learn more about the Scikit-learn module, I have some tutorials on Scikit-Learn machine learning.

Fortunately, for us, the people behind NLTK value the value of incorporating the sklearn module into the NLTK classifier approach. In this way, they created various SklearnClassifierAPIs. To use it, you just need to import it like this:

From nltk.classify.scikitlearn import SklearnClassifier

From here on, you can use any sklearnclassifier. For example, let's introduce more variants of the naive Bayesian algorithm:

From sklearn.naive_bayes import MultinomialNB , BernoulliNB

After how do you use them? As a result, this is very simple.

MNB_classifier = SklearnClassifier(MultinomialNB())
MNB_classifier .train (training_set)
Print( " MultinomialNB accuracy percent:" ,nltk .classify .accuracy (MNB_classifier, testing_set))
BNB_classifier = SklearnClassifier(BernoulliNB())
BNB_classifier .train (training_set)
Print( "BernoulliNB accuracy percent:" ,nltk .classify .accuracy (BNB_classifier, testing_set))

C'est si simple. Let us introduce more things:

From sklearn.linear_model import LogisticRegression,SGDClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC

Now all our classifiers should look like this:

Print( "Original Naive Bayes Algo accuracy percent:" , (nltk .classify  .accuracy (classifier, testing_set))* 100 )
classifier the .Show _most_informative_features ( 15 )
MNB_classifier = SklearnClassifier(MultinomialNB())
MNB_classifier .train (training_set)
Print( "MNB_classifier accuracy percent:" , (nltk .classify .accuracy (MNB_classifier, testing_set))* 100 )
BernoulliNB_classifier = SklearnClassifier(BernoulliNB())
BernoulliNB_classifier .train (training_set)
Print( "BernoulliNB_classifier accuracy percent:" , (nltk .classify .accuracy (BernoulliNB_classifier, testing_set))* 100 )
LogisticRegression_classifier = SklearnClassifier(LogisticRegression())
LogisticRegression_classifier .train (training_set)
Print( "LogisticRegression_classifier accuracy percent:" , (nltk .classify .accuracy (LogisticRegression_classifier, testing_set))* 100 )
SGDClassifier_classifier = SklearnClassifier(SGDClassifier())
SGDClassifier_classifier .train (training_set)
Print( "SGDClassifier_classifier accuracy percent:" , (nltk .classify .accuracy (SGDClassifier_classifier, testing_set))* 100 )
SVC_classifier = SklearnClassifier(SVC())
SVC_classifier .train (training_set)
Print( "SVC_classifier accuracy percent:" , (nltk .classify .accuracy (SVC_classifier, testing_set))* 100 )
LinearSVC_classifier = SklearnClassifier(LinearSVC())
LinearSVC_classifier .train (training_set)
Print( "LinearSVC_classifier accuracy percent:" , (nltk .classify .accuracy (LinearSVC_classifier, testing_set))* 100 )
NuSVC_classifier = SklearnClassifier(NuSVC())
NuSVC_classifier .train (training_set)
Print( "NuSVC_classifier accuracy percent:" , (nltk .classify .accuracy (NuSVC_classifier, testing_set))* 100 )

The result of running it should look like this:

Original Naive Bayes Algo accuracy percent: 63.0 
Most Informative Features
Thematic = True pos : neg = 9.1 : 1.0
secondly = True pos : neg = 8.5 : 1.0
narrates = True pos : neg = 7.8 : 1.0
rounded = True pos : neg = 7.1 : 1.0
supreme = True pos : neg = 7.1 : 1.0
Layered = True pos : neg = 7.1 : 1.0
crappy = True Neg : pos = 6.9 : 1.0
uplifting = True pos : neg = 6.2 : 1.0
ugh = True neg : pos = 5.3 : 1.0
mamet = True pos : neg = 5.1 : 1.0
gaining = True pos : neg = 5.1 : 1.0
wanda = True Neg : pos = 4.9 : 1.0
onset = True neg : pos = 4.9 :1.0
fantastic = True pos : neg = 4.5 : 1.0
kentucky = True pos : neg = 4.4 : 1.0
MNB_classifier accuracy percent: 66.0
BernoulliNB_classifier accuracy percent: 72.0
LogisticRegression_classifier accuracy percent: 64.0
SGDClassifier_classifier accuracy percent: 61.0
SVC_classifier accuracy percent: 45.0
LinearSVC_classifier accuracy percent: 68.0
NuSVC_classifier accuracy percent: 59.0

So, we can see that SVC errors are more common than correct, so we should probably discard it. but? Next we can try to use all of these algorithms at once. An algorithmic algorithm! To do this, we can create another classifier and generate the results of the classifier based on the results of other algorithms. It’s a bit like a voting system, so we only need an odd number of algorithms. This is what we will discuss in the next tutorial.

XVI. Using the NLTK combination algorithm

Now we know how to use a bunch of algorithm classifiers, like a child on Candy Island, telling them that they can only choose one, and we may find it difficult to select only one classifier. The good news is that you don’t have to! The combined classifier algorithm is a commonly used technique, which is implemented by creating a voting system. Each algorithm has one vote and the most votes are selected.

To do this, we want our new classifier to work like a typical NLTK classifier and have all the methods. Quite simply, with object-oriented programming, we can ensure that we inherit from the NLTK classifier class. To do this we will import it:

From nltk.classify import ClassifierI
from statistics import mode

We also import mode(the majority) because this will be the way we choose the maximum count.

Now let’s build our classifier class:

Class  VoteClassifier  (ClassifierI) : 
def __init__ (self, *classifiers) :
self._classifiers = classifiers

We call our class VoteClassifier, we inherit NLTK ClassifierI. Next, we assign the list of classifiers passed to our class self._classifiers.

Next, we will continue to create our own classification method. We intend to call it .classifyso that we can call it later .classify, just like the traditional NLTK classifier.

Def  classify  (self, features) :
Votes = []
For c in self._classifiers:
v = c.classify(features)
Votes.append(v)
Return mode(votes)

Quite simply, what we are doing here is to iterate through our list of classifier objects. Then, for each one, we ask it to be based on feature classification. Classification is considered a vote. After the traversal is complete, we return mode(votes), this is just the mode to return the vote.

This is what we really need, but I think another parameter, confidence is useful. Since we have a voting algorithm, we can also count the number of support and negative votes, and call it “confidence.” For example, the confidence of a 3/5 vote is weaker than a 5/5 vote. Therefore, we can literally return the voting ratio as a measure of confidence. This is our confidence method:

Def  confidence  (self, features) :
Votes = []
For c in self._classifiers:
v = c.classify(features)
Votes.append(v)
                Choice_votes = votes.count(mode(votes))
Conf = choice_votes / len(votes)
Return conf

Now let’s put things together:

Import nltk
Import random
From nltk.corpus import movie_reviews
From nltk.classify.scikitlearn import SklearnClassifier
Import pickle
From sklearn.naive_bayes import MultinomialNB, BernoulliNB
From sklearn.linear_model import LogisticRegression, SGDClassifier
From sklearn.svm import SVC, LinearSVC, NuSVC
From nltk.classify import ClassifierI
From statistics import mode
Class VoteClassifier(ClassifierI):
Def __init__(self, *classifiers):
self._classifiers = classifiers
Def classify(self, features): 
votes = []
for c in self._classifiers:
v = c.classify(features)
votes.append(v)
return mode(votes)
Def confidence(self, features): 
votes = []
for c in self._classifiers:
v = c.classify(features)
votes.append(v)
Choice_votes = votes.count(mode(votes)) 
conf = choice_votes / len(votes)
return conf
Documents =[(list(movie_reviewswords(fileid))category)[(list(movie_reviewswords(fileid))category)
For category in movie_reviews.categories()
for fileid in movie_reviews.fileids(category)]
Random.shuffle(documents)
All_words = []
For w in movie_reviews.words():
All_words.append(w.lower())
All _words = nltk.FreqDist(all_ words)
Word _features = list(all_ words.keys())[:3000]
Def find_features(document):
Words = set(document)
features = {}
for w in word_features:
fonctionnalités[w] = (w in words)
  Return features
#print((find_features(movie_reviews.words('neg/cv000_29416.txt')))))
Featuresets = [(find_features(rev), category) for (rev, category) in documents]
Training_set = featuresets[:1900]
Testing_set = featuresets[1900:]
#classifier = nltk.NaiveBayesClassifier.train(training_set)
Classifier_f = open("naivebayes.pickle","rb")
Classifier = pickle.load(classifier_f)
Classifier_f.close()
Print("Original Naive Bayes Algo accuracy percent:", (nltk.classify.accuracy(classifier, testing_set))*100)
classifier.show _most_ informative_features (15)
MNB_classifier = SklearnClassifier(MultinomialNB())
MNB _classifier.train(training_ set)
Print("MNB _classifier accuracy percent:", (nltk.classify.accuracy(MNB_ classifier, testing_set))*100)
BernoulliNB_classifier = SklearnClassifier(BernoulliNB())
BernoulliNB _classifier.train(training_ set)
Print("BernoulliNB _classifier accuracy percent:", (nltk.classify.accuracy(BernoulliNB_ classifier, testing_set))*100)
LogisticRegression_classifier = SklearnClassifier(LogisticRegression())
LogisticRegression _classifier.train(training_ set)
Print("LogisticRegression _classifier accuracy percent:", (nltk.classify.accuracy(LogisticRegression_ classifier, testing_set))*100)
SGDClassifier_classifier = SklearnClassifier(SGDClassifier())
SGDClassifier _classifier.train(training_ set)
Print("SGDClassifier _classifier accuracy percent:", (nltk.classify.accuracy(SGDClassifier_ classifier, testing_set))*100)
##SVC_classifier = SklearnClassifier(SVC()) 
##SVC_classifier.train(training_set)
##print("SVC_classifier accuracy percent:", (nltk.classify.accuracy(SVC_classifier, testing_set))*100)
LinearSVC_classifier = SklearnClassifier(LinearSVC())
LinearSVC _classifier.train(training_ set)
Print("LinearSVC _classifier accuracy percent:", (nltk.classify.accuracy(LinearSVC_ classifier, testing_set))*100)
NuSVC_classifier = SklearnClassifier(NuSVC())
NuSVC _classifier.train(training_ set)
Print("NuSVC _classifier accuracy percent:", (nltk.classify.accuracy(NuSVC_ classifier, testing_set))*100)
Voted_classifier = VoteClassifier(classifier,
NuSVC_classifier,
LinearSVC_classifier,
SGDClassifier_classifier,
MNB_classifier,
BernoulliNB_classifier,
LogisticRegression_classifier)
Print("voted _classifier accuracy percent:", (nltk.classify.accuracy(voted_ classifier, testing_set))*100)
Print("Classification:", voted _classifier.classify(testing_ set[ 0 ][ 0 ]), "Confidence %:",voted _classifier.confidence(testing_ set[ 0 ][ 0 ])*100)
Print("Classification:", voted _classifier.classify(testing_ set[ 1 ][ 0 ]), "Confidence %:",voted _classifier.confidence(testing_ set[ 1 ][ 0 ])*100)
Print("Classification:", voted _classifier.classify(testing_ set[ 2 ][ 0 ]), "Confidence %:",voted _classifier.confidence(testing_ set[ 2 ][ 0 ])*100)
Print("Classification:", voted _classifier.classify(testing_ set[ 3 ][ 0 ]), "Confidence %:",voted _classifier.confidence(testing_ set[ 3 ][ 0 ])*100)
Print("Classification:", voted _classifier.classify(testing_ set[ 4 ][ 0 ]), "Confidence %:",voted _classifier.confidence(testing_ set[ 4 ][ 0 ])*100)
Print("Classification:", voted _classifier.classify(testing_ set[ 5 ][ 0 ]), "Confidence %:",voted _classifier.confidence(testing_ set[ 5 ][ 0 ])*100)

So at the end, we run some sorter examples for the text. All our output:

Original Naive Bayes Algo accuracy percent: 66.0
Most Informative Features
Thematic = True pos : neg = 9.1 : 1.0
secondly = True pos : neg = 8.5 : 1.0
narrates = True pos : neg = 7.8 : 1.0
layered = True pos : neg = 7.1 : 1.0
rounded = True pos : neg = 7.1 : 1.0
Supreme = True pos : neg = 7.1 : 1.0
crappy = True neg: pos = 6.9 : 1.0
uplifting = True pos : neg = 6.2 : 1.0
ugh = True neg : pos = 5.3 : 1.0
gaining = True pos : neg = 5.1 : 1.0
mamet = True pos : neg = 5.1 : 1.0
wanda = True neg : pos = 4.9 : 1.0
onset = True neg : pos = 4.9 :1.0
fantastic = True pos : neg = 4.5 : 1.0
milos = True pos : neg = 4.4 : 1.0
MNB_classifier accuracy percent: 67.0
BernoulliNB_classifier accuracy percent: 67.0
LogisticRegression_classifier accuracy percent: 68.0
SGDClassifier_classifier accuracy percent: 57.99999999999999
LinearSVC_classifier accuracy percent: 67.0
NuSVC_classifier accuracy percent: 65.0
voted_classifier accuracy percent: 65.0
Classification: neg Confidence %:100.0
Classification: pos Confidence %: 57.14285714285714
Classification: neg Confidence %: 57.14285714285714
Classification: neg Confidence %: 57.14285714285714
Classification: pos Confidence %: 57.14285714285714
Classification: pos Confidence %: 85.71428571428571

XVII. Investigate bias using NLTK

In this tutorial we will discuss some issues. The main problem is that we have a fairly biased algorithm. You can test it by commenting out the scramble of the document, then training with the first 1900 and leaving the last 100 (all positive) comments. Test it and you will find that your accuracy is very poor.

Instead, you can test with the top 100 data, all of which are negative and use 1900 training. Here you will find that the accuracy is very high. This is a bad sign. This can mean a lot of things, and we have a lot of options to solve it.

In other words, the project we are considering suggests that we continue and use different data sets, so we will do so. Finally, we will find that there is still some deviation in this new data set, that is, it chooses negative things more often. The reason is that the negatives of negative reviews tend to be more positive than positive ones. This can be done with some simple weighting, but it can also be complicated. Maybe it’s another day’s tutorial. Now we are going to grab a new data set, which we will discuss in the next tutorial.

XVIII. Using NLTK to improve training data for sentiment analysis

So now is the time to train on the new data set. Our goal is to analyze Twitter’s sentiment, so we want every positive and negative statement in the dataset to be short. It happens that I have 5300+ positive and 5300+ negative movie reviews, which is a much shorter data set. We should be able to get more accuracy from a larger training set and fit Twitter tweets better.

I hosted these two files here, you can find them by downloading a short comment . Save these files as positive.txtet negative.txt.

Now we can build new data sets as before. What needs to be changed?

We need a new way to create our “document” variable, and then we need a new way to create the all_wordsvariable. Really no problem, I did this:

Short_pos = open ( "short_reviews/positive.txt" , "r" ). read ()
Short_neg = open ( "short_reviews/negative.txt" , "r" ). read ()
Documents = []
For r in short_pos. split ( 'n' ):
Documents.append( (r, "pos" ) )
For r in short_neg. split ( 'n' ):
Documents.append( (r, "neg" ) )
All_words = []
Short_pos_words = word_tokenize(short_pos)
Short_neg_words = word_tokenize(short_neg)
For w in short_pos_words:
All_words.append(w. lower ())
For w in short_neg_words:
All_words.append(w. lower ())
All_words = nltk.FreqDist(all_words)

Next, we also need to adjust our feature lookup function, mainly based on the words in the document, because our new sample has no beautiful .words()features. I continued and added the most common words:

Word_features = list(all_words.keys())[: 5000 ]
Def  find_features  (document) :
Words = word_tokenize(document)
Features = {}
For w in word_features:
Caractéristiques[w] = (w in words)
        Return features
Featuresets = [(find_features(rev), category) for (rev, category) in documents]
Random.shuffle(featuresets)

Other than that, the rest are the same. This is a complete script just in case you or I missed something:

This process takes a while. You may want to do something else. It took me about 30–40 minutes to get it all running, and I ran it on the i7 3930k. At the time of writing this article (2015), a general processor might take several hours. But this is a one-off process.

Import nltk
import random
from nltk.corpus import movie_reviews
from nltk.classify.scikitlearn import SklearnClassifier
import pickle
From sklearn.naive_bayes import MultinomialNB , BernoulliNB
from sklearn.linear_model import LogisticRegression, SGDClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
From nltk.classify import ClassifierI
from statistics import mode
From nltk.tokenize import word_tokenize
Class  VoteClassifier  (ClassifierI) : 
def __init__ (self, *classifiers) :
Self._classifiers = classifiers
        Def  classify  (self, features) :
Votes = []
For c in self._classifiers:
v = c.classify(features)
Votes.append(v)
Return mode(votes)
        Def  confidence  (self, features) :
Votes = []
For c in self._classifiers:
v = c.classify(features)
Votes.append(v)
                Choice_votes = votes.count(mode(votes))
Conf = choice_votes / len(votes)
Return conf
Short_pos = open( "short_reviews/positive.txt" , "r" ).read()
Short_neg = open( "short_reviews/negative.txt" , "r" ).read()
Documents = []
For r in short_pos.split( 'n' ):
Documents.append( (r, "pos" ) )
For r in short_neg.split( 'n' ):
Documents.append( (r, "neg" ) )
All_words = []
Short_pos_words = word_tokenize(short_pos)
Short_neg_words = word_tokenize(short_neg)
For w in short_pos_words:
All_words.append(w.lower())
For w in short_neg_words:
All_words.append(w.lower())
All_words = nltk.FreqDist(all_words)
Word_features = list(all_words.keys())[: 5000 ]
Def  find_features  (document) :
Words = word_tokenize(document)
Features = {}
For w in word_features:
Caractéristiques[w] = (w in words)
        Return features
#print((find_features(movie_reviews.words('neg/cv000_29416.txt')))))
Featuresets = [(find_features(rev), category) for (rev, category) in documents]
Random.shuffle(featuresets)
# positive data example: 
training_set = featuresets[: 10000 ]
Testing_set = featuresets[ 10000 :]
## 
### negative data example:
##training_set = featuresets[100:]
##testing_set = featuresets[:100]
Classifier = nltk.NaiveBayesClassifier.train(training_set)
Print( "Original Naive Bayes Algo accuracy percent:" , (nltk.classify.accuracy(classifier, testing_set))* 100 )
Classifier.show_most_informative_features( 15 )
MNB_classifier = SklearnClassifier(MultinomialNB())
MNB_classifier.train(training_set)
Print( "MNB_classifier accuracy percent:" , (nltk.classify.accuracy(MNB_classifier, testing_set))* 100 )
BernoulliNB_classifier = SklearnClassifier(BernoulliNB())
BernoulliNB_classifier.train(training_set)
Print( "BernoulliNB_classifier accuracy percent:" , (nltk.classify.accuracy(BernoulliNB_classifier, testing_set))* 100 )
LogisticRegression_classifier = SklearnClassifier(LogisticRegression())
LogisticRegression_classifier.train(training_set)
Print( "LogisticRegression_classifier accuracy percent:" , (nltk.classify.accuracy(LogisticRegression_classifier, testing_set))* 100 )
SGDClassifier_classifier = SklearnClassifier(SGDClassifier())
SGDClassifier_classifier.train(training_set)
Print( "SGDClassifier_classifier accuracy percent:" , (nltk.classify.accuracy(SGDClassifier_classifier, testing_set))* 100 )
##SVC_classifier = SklearnClassifier(SVC()) 
##SVC_classifier.train(training_set)
##print("SVC_classifier accuracy percent:", (nltk.classify.accuracy(SVC_classifier, testing_set))*100)
LinearSVC_classifier = SklearnClassifier(LinearSVC())
LinearSVC_classifier.train(training_set)
Print( "LinearSVC_classifier accuracy percent:" , (nltk.classify.accuracy(LinearSVC_classifier, testing_set))* 100 )
NuSVC_classifier = SklearnClassifier(NuSVC())
NuSVC_classifier.train(training_set)
Print( "NuSVC_classifier accuracy percent:" , (nltk.classify.accuracy(NuSVC_classifier, testing_set))* 100 )
Voted_classifier = VoteClassifier(
NuSVC_classifier,
LinearSVC_classifier,
MNB_classifier,
BernoulliNB_classifier,
LogisticRegression_classifier)
Print( "voted_classifier accuracy percent:" , (nltk.classify.accuracy(voted_classifier, testing_set))* 100 )

Sortie:

Original Naive Bayes Algo accuracy percent: 66.26506024096386 
Most Informative Features
Refreshing = True pos : neg = 13.6 : 1.0
captures = True pos : neg = 11.3 : 1.0
stupid = True neg : pos = 10.7 : 1.0
tender = True pos : neg = 9.6 : 1.0
meandering = True neg : pos = 9.1 : 1.0
Tv = True neg : pos = 8.6 : 1.0
low-key = TruePos : neg = 8.3 : 1.0
thoughtful = True pos : neg = 8.1 : 1.0
banal = True neg : pos = 7.7 : 1.0
amateurish = True neg : pos = 7.7 : 1.0
terrific = True pos : neg = 7.6 : 1.0
record = True Pos : neg = 7.6 : 1.0
captivating = True pos : neg = 7.6 :1.0
portrait = True pos : neg = 7.4 : 1.0
culture = True pos : neg = 7.3 : 1.0
MNB_classifier accuracy percent: 65.8132530120482
BernoulliNB_classifier accuracy percent: 66.71686746987952
LogisticRegression_classifier accuracy percent: 67.16867469879519
SGDClassifier_classifier accuracy percent: 65.8132530120482
LinearSVC_classifier accuracy percent: 66.71686746987952
NuSVC_classifier accuracy percent: 60.09036144578314
voted_classifier accuracy percent: 65.66265060240963

Yes, I bet you spent a while, so in the next tutorial we will talk about cornichoneverything!

XIX. Use NLTK to create modules for sentiment analysis

With this new data set and new classifiers, we can move on. As you may have noticed, this new data set takes longer to train because it is a larger collection. I have shown you that by pickelserializing or serializing the trained classifiers, we can actually save a lot of time. These classifiers are just objects.

I have shown you how to use it pickelto implement it, so I encourage you to try it yourself. If you need help, I will paste the complete code... but be careful, do it yourself!

This process takes a while. You may want to do something else. It took me about 30–40 minutes to get it all running, and I ran it on the i7 3930k. At the time of writing this article (2015), a general processor might take several hours. But this is a one-off process.

Import nltk
import random
#from nltk.corpus import movie_reviews
from nltk.classify.scikitlearn import SklearnClassifier
import pickle
from sklearn.naive_bayes import MultinomialNB , BernoulliNB
from sklearn.linear_model import LogisticRegression, SGDClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from nltk. Classify import ClassifierI
from statistics import mode
from nltk.tokenize import Word_tokenize
Class  VoteClassifier  (ClassifierI) : 
def __init__ (self, *classifiers) :
Self._classifiers = classifiers
        Def  classify  (self, features) :
Votes = []
For c in self._classifiers:
v = c.classify(features)
Votes.append(v)
Return mode(votes)
        Def  confidence  (self, features) :
Votes = []
For c in self._classifiers:
v = c.classify(features)
Votes.append(v)
                Choice_votes = votes.count(mode(votes))
Conf = choice_votes / len(votes)
Return conf
Short_pos = open( "short_reviews/positive.txt" , "r" ).read()
Short_neg = open( "short_reviews/negative.txt" , "r" ).read()
# move this up here
All_words = []
Documents = []
# j is adject, r is adverb, and v is verb 
#allowed_word_types = ["J","R","V"]
allowed_word_types = [ "J" ]
For p in short_pos.split( 'n' ):
Documents.append( (p, "pos" ) )
Words = word_tokenize(p)
Pos = nltk.pos_tag(words)
For w in pos:
si w[ 1 ][ 0 ] in allowed_word_types:
All_words.append(w[ 0 ].lower())
For p in short_neg.split( 'n' ):
Documents.append( (p, "neg" ) )
Words = word_tokenize(p)
Pos = nltk.pos_tag(words)
For w in pos:
si w[ 1 ][ 0 ] in allowed_word_types:
All_words.append(w[ 0 ].lower())
Save_documents 
= open( "pickled_algos/documents.pickle" , "wb" )
Pickle.dump(documents, save_documents)
Save_documents.close()
All_words = nltk.FreqDist(all_words)
Word_features = list(all_words.keys())[: 5000 ]
Save_word_features = open( "pickled_algos/word_features5k.pickle" , "wb" )
Pickle.dump(word_features, save_word_features)
Save_word_features.close()
Def  find_features  (document) :
Words = word_tokenize(document)
Features = {}
For w in word_features:
Caractéristiques[w] = (w in words)
        Return features
Featuresets = [(find_features(rev), category) for (rev, category) in documents]
Random.shuffle(featuresets)
Print(len(featuresets))
Testing_set = featuresets[ 10000 :]
Training_set = featuresets[: 10000 ]
Classifier = nltk.NaiveBayesClassifier.train(training_set)
Print( "Original Naive Bayes Algo accuracy percent:" , (nltk.classify.accuracy(classifier, testing_set))* 100 )
Classifier.show_most_informative_features( 15 )
############### 
save_classifier = open( "pickled_algos/originalnaivebayes5k.pickle" , "wb" )
Pickle.dump(classifier, save_classifier)
Save_classifier.close()
MNB_classifier = SklearnClassifier(MultinomialNB())
MNB_classifier.train(training_set)
Print( "MNB_classifier accuracy percent:" , (nltk.classify.accuracy(MNB_classifier, testing_set))* 100 )
Save_classifier = open( "pickled_algos/MNB_classifier5k.pickle" , "wb" )
Pickle.dump(MNB_classifier, save_classifier)
Save_classifier.close()
BernoulliNB_classifier = SklearnClassifier(BernoulliNB())
BernoulliNB_classifier.train(training_set)
Print( "BernoulliNB_classifier accuracy percent:" , (nltk.classify.accuracy(BernoulliNB_classifier, testing_set))* 100 )
Save_classifier = open( "pickled_algos/BernoulliNB_classifier5k.pickle" , "wb" )
Pickle.dump(BernoulliNB_classifier, save_classifier)
Save_classifier.close()
LogisticRegression_classifier = SklearnClassifier(LogisticRegression())
LogisticRegression_classifier.train(training_set)
Print( "LogisticRegression_classifier accuracy percent:" , (nltk.classify.accuracy(LogisticRegression_classifier, testing_set))* 100 )
Save_classifier = open( "pickled_algos/LogisticRegression_classifier5k.pickle" , "wb" )
Pickle.dump(LogisticRegression_classifier, save_classifier)
Save_classifier.close()
LinearSVC_classifier = SklearnClassifier(LinearSVC())
LinearSVC_classifier.train(training_set)
Print( "LinearSVC_classifier accuracy percent:" , (nltk.classify.accuracy(LinearSVC_classifier, testing_set))* 100 )
Save_classifier = open( "pickled_algos/LinearSVC_classifier5k.pickle" , "wb" )
Pickle.dump(LinearSVC_classifier, save_classifier)
Save_classifier.close()
##NuSVC_classifier = SklearnClassifier(NuSVC()) 
##NuSVC_classifier.train(training_set)
##print("NuSVC_classifier accuracy percent:", (nltk.classify.accuracy(NuSVC_classifier, testing_set))*100)
SGDC_classifier = SklearnClassifier(SGDClassifier())
SGDC_classifier.train(training_set)
Print( "SGDClassifier accuracy percent:" ,nltk.classify.accuracy(SGDC_classifier, testing_set)* 100 )
Save_classifier = open( "pickled_algos/SGDC_classifier5k.pickle" , "wb" )
Pickle.dump(SGDC_classifier, save_classifier)
Save_classifier.close()

Now you only need to run it once. If you wish, you can run it anytime, but now you are ready to create a sentiment analysis module. This is what we call sentiment_mod.pya file:

#File: sentiment_mod.py
Import nltk
import random
#from nltk.corpus import movie_reviews
from nltk.classify.scikitlearn import SklearnClassifier
import pickle
from sklearn.naive_bayes import MultinomialNB , BernoulliNB
from sklearn.linear_model import LogisticRegression, SGDClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from nltk. Classify import ClassifierI
from statistics import mode
from nltk.tokenize import Word_tokenize
Class  VoteClassifier  (ClassifierI) : 
def __init__ (self, *classifiers) :
Self._classifiers = classifiers
        Def  classify  (self, features) :
Votes = []
For c in self._classifiers:
v = c.classify(features)
Votes.append(v)
Return mode(votes)
        Def  confidence  (self, features) :
Votes = []
For c in self._classifiers:
v = c.classify(features)
Votes.append(v)
                Choice_votes = votes.count(mode(votes))
Conf = choice_votes / len(votes)
Return conf
Documents_f = open( "pickled_algos/documents.pickle" , "rb" )
Documents = pickle.load(documents_f)
Documents_f.close()
Word_features5k_f = open( "pickled_algos/word_features5k.pickle" , "rb" )
Word_features = pickle.load(word_features5k_f)
Word_features5k_f.close()
Def  find_features  (document) :
Words = word_tokenize(document)
Features = {}
For w in word_features:
Caractéristiques[w] = (w in words)
        Return features
Featuresets_f 
= open( "pickled_algos/featuresets.pickle" , "rb" )
Featuresets = pickle.load(featuresets_f)
Featuresets_f.close()
Random.shuffle(featuresets)
Print(len(featuresets))
Testing_set = featuresets[ 10000 :]
Training_set = featuresets[: 10000 ]
Open_file 
= open( "pickled_algos/originalnaivebayes5k.pickle" , "rb" )
Classifier = pickle.load(open_file)
Open_file.close()
Open_file 
= open( "pickled_algos/MNB_classifier5k.pickle" , "rb" )
MNB_classifier = pickle.load(open_file)
Open_file.close()
Open_file 
= open( "pickled_algos/BernoulliNB_classifier5k.pickle" , "rb" )
BernoulliNB_classifier = pickle.load(open_file)
Open_file.close()
Open_file 
= open( "pickled_algos/LogisticRegression_classifier5k.pickle" , "rb" )
LogisticRegression_classifier = pickle.load(open_file)
Open_file.close()
Open_file 
= open( "pickled_algos/LinearSVC_classifier5k.pickle" , "rb" )
LinearSVC_classifier = pickle.load(open_file)
Open_file.close()
Open_file 
= open( "pickled_algos/SGDC_classifier5k.pickle" , "rb" )
SGDC_classifier = pickle.load(open_file)
Open_file.close()
Voted_classifier = VoteClassifier(
Classifier,
LinearSVC_classifier,
MNB_classifier,
BernoulliNB_classifier,
LogisticRegression_classifier)
Def  sentiment  (text) :
Feats = find_features(text)
Return voted_classifier.classify(feats),voted_classifier.confidence(feats)

So here, in addition to the final function, there is nothing new, it is very simple. This function is the key to interacting with us from here. This function, which we call “emotion”, takes a parameter, text. Here, we use the find_featuresfunctions we have created to decompose these features. All we have to do now is to use our voting classifier to return the classification and return the confidence of the classification.

With this, we can now use this file, as well as the emotion function, as a module. The following is a sample script that uses this module:

Import sentiment_mod as s
Print(s.sentiment( "This movie was awesome! The acting was great, plot was wonderful, and there were pythons...so yea!" ))
Print(s.sentiment( "This movie was utter junk. There were absolutely 0 pythons. I don't see what the point was at all. Horrible movie, 0/10" ))

Comme prévu, pythonthe comments with the movie are obviously good, and no pythonmovie is junk. Both have 100% confidence.

It took me about 5 seconds to import the module, because we saved the classifier and it might take 30 minutes without saving. Thanks to cornichonyour time, there will be big differences depending on your processor. If you keep going, I will say that you may want to see it too joblib.

Now that we have this great module, it works very easily, what can we do? I suggest that we go to Twitter for real-time sentiment analysis!

XX. NLTK Twitter sentiment analysis

Now that we have an sentiment analysis module, we can apply it to any text, but it’s better to have short text, like Twitter! To this end, we will combine this tutorial with the Twitter Streaming API Tutorial.

The initial code for this tutorial is:

From tweepy import Stream
from tweepy import OAuthHandler
from tweepy.streaming import StreamListener
#consumer key, consumer secret, access token, access secret. 
ckey= "fsdfasdfsafsffa"
csecret= "asdfsadfsadfsadf"
atoken= "asdf-aassdfs"
asecret= "asdfsadfsdafsdafs"
Class  listener  (StreamListener) :
        Def  on_data  (self, data) :
Print(data)
Return ( True )
        Def  on_error  (self, status) : 
print status
Auth = OAuthHandler(ckey, csecret)
Auth.set_access_token(atoken, asecret)
twitterStream = Stream(auth, listener())
twitterStream.filter(track=[ "car" ])

This is enough to print voitureall the data of a streaming live tweet containing words . We can use jsonmodules json.loads(data)to load data variables, and then we can reference specific ones tweet:

Tweet = all_data[ "text" ]

Since we have a tweet, we can easily pass it to our sentiment_modmodule.

From tweepy import Stream
from tweepy import OAuthHandler
from tweepy.streaming import StreamListener
import json
import sentiment_mod as s
#consumer key, consumer secret, access token, access secret. 
ckey= "asdfsafsafsaf"
csecret= "
asdfasdfsadfsa " atoken= "asdfsadfsafsaf-asdfsaf"
asecret= "asdfsadfsadfsadfsadfsad"
From twitterapistuff import *
Class  listener  (StreamListener) :
        Def  on_data  (self, data) :
                All_data = json.loads(data)
                Tweet = all_data[ "text" ]
Sentiment_value, confidence = s.sentiment(tweet)
Print(tweet, sentiment_value, confidence)
                If confidence* 100 >= 80 :
Output = open( "twitter-out.txt" , "a" )
Output.write(sentiment_value)
Output.write( 'n' )
Output.close()
                Return  True
        Def  on_error  (self, status) :
Print(status)
Auth = OAuthHandler(ckey, csecret)
Auth.set_access_token(atoken, asecret)
twitterStream = Stream(auth, listener())
twitterStream.filter(track=[ "happy" ])

In addition to this, we also save the results to the output file twitter-out.txt.

Next, what is the data analysis without the chart is complete? Let’s combine another tutorial to draw a live streaming graph from sentiment analysis on the Twitter API.

XXI. Using NLTK to draw Twitter real-time sentiment analysis

Now that we have obtained real-time data from the Twitter Streaming API, why are there no activity diagrams showing emotional trends? To this end, we will combine this tutorial with the matplotlib drawing tutorial.

If you want to learn more about how the code works, see this tutorial. otherwise:

Import matplotlib.pyplot as plt
import matplotlib.animation as animation
from matplotlib import style
temps d'importation
Style.use( "ggplot" )
Fig = plt.figure()
Ax1 = fig.add_subplot( 1 , 1 , 1 )
Def  animate  (i) : 
pullData = open( "twitter-out.txt" , "r" ).read()
Lines = pullData.split( 'n' )
        Xar = []
Yar = []
        x = 0 
y = 0
        For l in lines[- 200 :]:
x += 1
if "pos" in l:
y += 1
elif "neg" in l:
y -= 1
                Xar.append(x)
Yar.append(y)
        Ax1.clear()
Ax1.plot(xar,yar)
Ani = animation.FuncAnimation(fig, animate, interval= 1000 )
Plt.show()

XXII. Stanford NER marker and named entity recognition

The Stanford NER marker provides an alternative to NLTK’s Named Entity Recognition (NER) classifier. This marker is largely seen as a standard for named entity recognition, but because it uses advanced statistical learning algorithms, its computational overhead is greater than the options offered by NLTK.

One of the big advantages of the Stanford NER marker is that we have several different models to extract named entities. We can use any of the following:

  • Three types of models for identifying locations, people, and organizations
  • Four types of models for identifying locations, people, organizations, and miscellaneous entities
  • Seven types of models, identifying location, people, organization, time, money, percentage and date

In order to continue, we need to download the model and potfiles, because the NER classifier is written in Java. These are available free of charge from the Stanford Natural Language Processing Group . NTLK For the convenience of us, NLTK provides a wrapper for the Stanford marker, so we can use it in the best language (of course Python)!

StanfordNERTaggerThe parameters passed to the class include:

  • The path of the classification model (the following three types of models are used)
  • potPath to the Stanford marker file
  • Training data encoding (default is ASCII)

Here’s how we set it up to mark sentences using three types of models:

# -*- coding: utf-8 -*-
From nltk.tag import StanfordNERTagger
from nltk.tokenize import word_tokenize
St = StanfordNERTagger( '/usr/share/stanford-ner/classifiers/english.all.3class.distsim.crf.ser.gz' ,
'/usr/share/stanford-ner/stanford-ner.jar' ,
Encoding= 'utf-8' )
Text = 'While in France, Christine Lagarde discussed short-term stimulus efforts in a recent interview with the Wall Street Journal.'
Tokenized_text = word_tokenize(text)
Classified_text = st.tag(tokenized_text)
Print(classified_text)

Once we follow the word segmentation and classify the sentences, we will see that the marker produces the following list of tuples:

[('While', 'O'), ('in', 'O'), ('France', 'LOCATION'), (',', 'O'), ('Christine', 'PERSON') , ('Lagarde', 'PERSON'), ('discussed', 'O'), ('short-term', 'O'), ('stimulus', 'O'), ('efforts', 'O '), ('in', 'O'), ('a', 'O'), ('recent', 'O'), ('interview', 'O'), ('with', 'O '), ('the', 'O'), ('Wall', 'ORGANIZATION'), ('Street', 'ORGANIZATION'), ('Journal', 'ORGANIZATION'), ('.', 'O ')]

Great!Each tag uses PERSON, LOCATION, ORGANISATIONou Otags (using our three types of models). ORepresents only the other, unnamed entities.

This list can now be used to test the annotated data, which we will cover in the next tutorial.

XXIII. Testing the accuracy of the NLTK and Stanford NER markers

We know how to use two different NER classifiers! But which one should we choose, NLTK or Stanford? Let’s do some testing to find out the answer.

The first thing we need is some labeled reference data to test our NER classifier. One way to get this data is to find a large number of articles and mark each tag as a named entity (for example, people, organization, location) or other non-named entity. Then we can test our separate NER classifier with the correct label we know.

Unfortunately, this is very time consuming! The good news is that there is a manually annotated data set that is freely available with over 16,000 English sentences. There are also data sets in German, Spanish, French, Italian, Dutch, Polish, Portuguese and Russian!

This is an annotated sentence from the dataset:

Founding O 
member O
Kojima I -PER
Minoru I -PER
Played O
guitar O
on O
Good I -MISC
Day I -MISC
, O
and O
Wardanceis the I -misc
Cover O
of O
A O
Song O
by O
UK the I -LOC
Post O
punk O
industrial O
band O
Killing I -ORG
Joke I -ORG
. O

Let’s read, split, and manipulate the data to make it a better format for testing.

Import nltk
from nltk.tag import StanfordNERTagger
from nltk.metrics.scores import accuracy
Raw_annotations = open( "/usr/share/wikigold.conll.txt" ).read()
Split_annotations = raw_annotations.split()
# Amend class annotations to reflect Stanford's NERTagger 
for n,i in enumerate(split_annotations):
if i == "I-PER" :
Split_annotations[n] = "PERSON"
if i == "I-ORG" :
Split_annotations[n] = "ORGANIZATION"
if i == "I-LOC" :
Split_annotations[n] = "LOCATION"
# Group NE data into tuples 
def group (lst, n) :
for i in range( 0 , len(lst), n):
Val = lst[i:i+n]
If len(val) == n:
yield tuple(val)
Reference_annotations = list(group(split_annotations, 2 ))

Ok, it looks good! However, we also need to paste the “clean” form of this data into our NER classifier. Let’s do it.

Pure_tokens = split_annotations[::2]

This reads in the data, splits it by whitespace, and then takes split_annotationsa subset of everything in increments of two (starting from the zeroth element) . This produces a data set similar to the (smaller) example below:

['Founding', 'member', 'Kojima', 'Minoru', 'played', 'guitar', 'on', 'Good', 'Day', ',', 'and', 'Wardanceis', ' Cover', 'of', 'a', 'song', 'by', 'UK', 'post', 'punk', 'industrial', 'band', 'Killing', 'Joke', '.' ]

Let’s go ahead and test the NLTK classifier:

Tagged_words = nltk.pos_tag(pure_tokens)
nltk_unformatted_prediction = nltk.ne_chunk(tagged_words)

Since the NLTK NER classifier generates trees (including POS tags), we need to do some extra data manipulation to get the proper form for testing.

#Convert prediction to multiline string and then to list (includes pos tags)
Multiline_string = nltk.chunk.tree2conllstr(nltk_unformatted_prediction)
Listed_pos_and_ne = multiline_string.split()
# Delete pos tags and rename
Del listed_pos_and_ne[ 1 :: 3 ]
Listed_ne = listed_pos_and_ne
# Amend class  annotations  for  consistency  with  reference_annotations
for n,i in enumerate(listed_ne):
if i == "B-PERSON" :
Listed_ne[n] = "PERSON"
if i == "I-PERSON" :
Listed_ne[n] = "PERSON"
if i == "B-ORGANIZATION" :
Listed_ne[n] = "ORGANIZATION"
if i == "I-ORGANIZATION" :
Listed_ne[n] = "ORGANIZATION"
if i == "B-LOCATION" :
Listed_ne[n] = "LOCATION"
if i == "I-LOCATION" :
Listed_ne[n] = "LOCATION"
if i == "B-GPE" :
Listed_ne[n] = "LOCATION"
if i == "I-GPE" :
Listed_ne[n] = "LOCATION"
# Group prediction into tuples
Nltk_formatted_prediction = list(group(listed_ne, 2 ))

Now we can test the accuracy of NLTK.

Nltk_accuracy = accuracy(reference_annotations, nltk_formatted_prediction) print(nltk_accuracy)

Wow, the accuracy rate .8971!

Let us now test the Stanford classifier. Because this classifier generates output in tuples, testing does not require more data manipulation.

St = StanfordNERTagger( '/usr/share/stanford-ner/classifiers/english.all.3class.distsim.crf.ser.gz' ,
'/usr/share/stanford-ner/stanford-ner.jar' ,
Encoding= 'utf-8' )
Stanford_prediction = st.tag(pure_tokens)
Stanford_accuracy = accuracy(reference_annotations, stanford_prediction)
Print (stanford_accuracy)

.9223The accuracy rate! better!

If you want to draw this, here are some extra code. If you want to learn more about how this works, check out the matplotlib series:

Import numpy as np
Import matplotlib.pyplot as plt
from matplotlib import style
Style.use( 'fivethirtyeight' )
N = 1 
ind = np.arange(N) # the x locations for the groups
width = 0.35 # the width of the bars
Fig, ax = plt.subplots()
Stanford_percentage = stanford_accuracy * 100 
rects1 = ax.bar(ind, stanford_percentage, width, color= 'r' )
Nltk_percentage = nltk_accuracy * 100 
rects2 = ax.bar(ind+width, nltk_percentage, width, color= 'y' )
# add some text for labels, title and axes ticks 
ax.set_xlabel( 'Classifier' )
Ax.set_ylabel( 'Accuracy (by percentage)' )
Ax.set_title( 'Accuracy by NER Classifier' )
Ax.set_xticks(ind+width)
Ax.set_xticklabels( ( '' ) )
Ax.legend( (rects1[ 0 ], rects2[ 0 ]), ( 'Stanford' , 'NLTK' ), bbox_to_anchor=( 1.05 , 1 ), loc= 2 , borderaxespad= 0. )
Def  autolabel  (rects) : 
# attach some text labels
for rect in rects:
Height = rect.get_height()
Ax.text(rect.get_x()+rect.get_width()/ 2. , 1.02 *height, '%10.2f' % float(height),
Ha= 'center' , va= 'bottom' )
Autolabel(rects1)
Autolabel(rects2)
Plt.show()
0*RJoEUw0f1hCJ0yPH - NLTK - SWAYAM MITTAL - Moyenne

XXIV. testing the speed of the NLTK and Stanford NER markers

We have tested the accuracy of our NER classifier, but there are more issues to consider when deciding which classifier to use. Let’s test the speed!

We know that we are comparing the same thing, we will test it in the same article. Use this episode in NBC News:

House Speaker John Boehner became animated Tuesday over  the proposed Keystone Pipeline, castigating the Obama administration for  not having the project.
Republican House Speaker John Boehner says there's "nothing complex about the Keystone Pipeline,"  and  that  it 's time  to build it .
"Complex? You think the Keystone Pipeline is complex?!" Boehner responded to a questioner. "It's been under study for five years! We build pipelines in America every day. Do you realize that are 200,000 miles of pipelines in the United States? "
At The Speaker Wentworth ON : "And at The only reason at The President is's Involved in at The Keystone Pipeline IS Because IT Crosses AN International's boundary the Listen, WE CAN Build IT There's Nothing Complex the About at The Keystone Pipeline - IT's Time to Build IT..."
Of Said Boehner at The President is NO excuse HAD AT the this Point to  not give at The Pipeline at The Go-Ahead the After  at The State Department Report Released A ON catalog on Friday Indicating, at The Project Impact Would have have A minimal ON  at The Environment.
Republicans have long pushed for construction of  the project, which enjoys some measure of Democratic support as well. The GOP is  considering conditioning an extension of  the debt limit on approval of  the project by Obama.
The White House, though, has said that  it has no timetable for a final decision on  the project.

First, we perform the import and process the article through reading and word segmentation.

# -*- coding: utf-8 -*-
Import nltk
import os
Import numpy as np
Import matplotlib.pyplot as plt
from matplotlib import style
from nltk import pos_tag
from nltk.tag import StanfordNERTagger
from nltk.tokenize import word_tokenize
Style.use( 'fivethirtyeight' )
# Process text 
def process_text (txt_file) :
raw_text = open( "/usr/share/news_article.txt" ).read()
Token_text = word_tokenize(raw_text)
Return token_text

Génial! Now let’s write some functions to split our classification task. Because the NLTK NEG classifier requires a POS tag, we will add a POS tag to our NLTK function.

# Stanford NER tagger 
def stanford_tagger (token_text) :
st = StanfordNERTagger( '/usr/share/stanford-ner/classifiers/english.all.3class.distsim.crf.ser.gz' ,
'/usr/share/stanford-ner /stanford-ner.jar' ,
Encoding= 'utf-8' )
Ne_tagged = st.tag(token_text)
Return (ne_tagged)
# NLTK POS and NER 
taggers def nltk_tagger (token_text) :
Tagged_words = nltk.pos_tag(token_text)
Ne_tagged = nltk.ne_chunk(tagged_words)
Return (ne_tagged)

Each classifier needs to read the article and classify the named entities, so we wrap these functions in a larger function to make timing easier.

Def  stanford_main  () :
Print(stanford_tagger(process_text(txt_file)))
Def  nltk_main  () : 
print(nltk_tagger(process_text(txt_file)))

When we call our program, we call these functions. We will os.times()wrap our stanford_main()somme nltk_main()function in the function call , taking the fourth index, which is the elapsed time. Then we will plot our results.

If __name__ == '__main__' :
Stanford_t0 = os .times()[ 4 ]
Stanford_main()
Stanford_t1 = os .times()[ 4 ]
Stanford_total_time = stanford_t1 - stanford_t0
        Nltk_t0 = os .times()[ 4 ]
Nltk_main()
Nltk_t1 = os .times()[ 4 ]
Nltk_total_time = nltk_t1 - nltk_t0
        Time_plot(stanford_total_time, nltk_total_time)

For our drawing, we use the time_plot()function:

Def  time_plot  (stanford_total_time, nltk_total_time) : 
N = 1
ind = np.arange(N) # the x locations for the groups
width = 0.35 # the width of the bars
Stanford_total_time = stanford_total_time
Nltk_total_time = nltk_total_time
Fig, ax = plt.subplots()
Rects1 = ax.bar(ind, stanford_total_time, width, color= 'r' )
Rects2 = ax.bar(ind+width, nltk_total_time, width, color= 'y' )
        # Add text for labels, title and axes ticks 
ax.set_xlabel( 'Classifier' )
Ax.set_ylabel( 'Time (in seconds)' )
Ax.set_title( 'Speed ​​by NER Classifier' )
Ax.set_xticks(ind+width)
Ax.set_xticklabels( ( '' ) )
Ax.legend( (rects1[ 0 ], rects2[ 0 ]), ( 'Stanford' , 'NLTK' ), bbox_to_anchor=( 1.05 , 1 ), loc= 2 , borderaxespad= 0. )
        Def  autolabel  (rects) : 
# attach some text labels
for rect in rects:
Height = rect.get_height()
Ax.text(rect.get_x()+rect.get_width()/ 2. , 1.02 *height, '%10.2f' % float(height),
Ha= 'center' , va= 'bottom' )
        Autolabel(rects1)
Autolabel(rects2)
Plt.show()

Wow, NLTK is as fast as lightning! It seems that Stanford is more accurate, but NLTK is faster. This is important information to know when balancing the precision of our preferences with the computing resources required.

But wait, there is still a problem. Our output is ugly! This is a small sample from Stanford University:

[('House''ORGANIZATION')('Speaker''O')('John''PERSON')('Boehner''PERSON')('became''O')('animated''O')('Tuesday''O')('over''O')('the''O')('proposed''O')('Keystone''ORGANIZATION')('Pipeline''ORGANIZATION')('''O')('castigating''O')('the''O')('Obama''PERSON')('administration''O')('for''O')('not''O')('having''O')('approved''O')('the''O')('project''O')('yet''O')('''O')[('House''ORGANIZATION')('Speaker''O')('John''PERSON')('Boehner''PERSON')('became''O')('animated''O')('Tuesday''O')('over''O')('the''O')('proposed''O')('Keystone''ORGANIZATION')('Pipeline''ORGANIZATION')('''O')('castigating''O')('the''O')('Obama''PERSON')('administration''O')('for''O')('not''O')('having''O')('approved''O')('the''O')('project''O')('yet''O')('''O')

And NLTK:

( S  ( ORGANIZATION House/NNP) Speaker/NNP ( PERSON John/NNP Boehner/NNP) became/VBD animated/VBN Tuesday/NNP over/IN the/DT proposed/VBN ( PERSON Keystone/NNP Pipeline/NNP) , /, Castigating/VBG the/DT ( ORGANIZATION Obama/NNP) administration/NN for/IN not/RB having/VBG approved/VBN the/DT project/NN yet/RB ./.

Let’s turn them into a readable form in the next tutorial.

0*NBmfg1XA1e2gd0dT - NLTK - SWAYAM MITTAL - Moyenne

XXV. Create a readable list of named entities using BIO tags

Now that we have completed the test, let’s turn our named entity into a good readable format.

Again, we will use the same news from NBC News:

House Speaker John Boehner became animated Tuesday over  the proposed Keystone Pipeline, castigating the Obama administration for  not having the project.
Republican House Speaker John Boehner says there's "nothing complex about the Keystone Pipeline,"  and  that  it 's time  to build it .
"Complex? You think the Keystone Pipeline is complex?!" Boehner responded to a questioner. "It's been under study for five years! We build pipelines in America every day. Do you realize that are 200,000 miles of pipelines in the United States? "
At The Speaker Wentworth ON : "And at The only reason at The President is's Involved in at The Keystone Pipeline IS Because IT Crosses AN International's boundary the Listen, WE CAN Build IT There's Nothing Complex the About at The Keystone Pipeline - IT's Time to Build IT..."
Of Said Boehner at The President is NO excuse HAD AT the this Point to  not give at The Pipeline at The Go-Ahead the After  at The State Department Report Released A ON catalog on Friday Indicating, at The Project Impact Would have have A minimal ON  at The Environment.
Republicans have long pushed for construction of  the project, which enjoys some measure of Democratic support as well. The GOP is  considering conditioning an extension of  the debt limit on approval of  the project by Obama.
The White House, though, has said that  it has no timetable for a final decision on  the project.

Our NTLK output is already a tree (just the last step), so let’s take a look at our Stanford output. We will mark the tag with BIO, B for the beginning of the named entity, I for the internal, and O for the other. For example, if our sentence is yes Barack Obama went to Greece today, we should mark it as Barack-B Obama-I went-O to-O Greece-B today-O. To do this, we will write a series of conditions to check the labels of the current and previous Otags.

# -*- coding: utf-8 -*-
Import nltk
import os
Import numpy as np
Import matplotlib.pyplot as plt
from matplotlib import style
from nltk import pos_tag
from nltk.tag import StanfordNERTagger
from nltk.tokenize import word_tokenize
from nltk.chunk import conlltags2tree
from nltk.tree import Tree
Style.use( 'fivethirtyeight' )
# Process text 
def process_text (txt_file) :
raw_text = open( "/usr/share/news_article.txt" ).read()
Token_text = word_tokenize(raw_text)
Return token_text
# Stanford NER tagger 
def stanford_tagger (token_text) :
st = StanfordNERTagger( '/usr/share/stanford-ner/classifiers/english.all.3class.distsim.crf.ser.gz' ,
'/usr/share/stanford-ner /stanford-ner.jar' ,
Encoding= 'utf-8' )
Ne_tagged = st.tag(token_text)
Return (ne_tagged)
# NLTK POS and NER 
taggers def nltk_tagger (token_text) :
Tagged_words = nltk.pos_tag(token_text)
Ne_tagged = nltk.ne_chunk(tagged_words)
Return (ne_tagged)
# Tag tokens with standard NLP BIO tags 
def bio_tagger (ne_tagged) :
Bio_tagged = []
Prev_tag = "O"
for token, tag in ne_tagged:
if tag == "O" : #O
Bio_tagged.append((token, tag))
Prev_tag = tag
Continue
if tag != "O" and prev_tag == "O" : # Begin NE
bio_tagged.append((token, "B-" +tag))
Prev_tag = tag
Elif prev_tag != "O" and prev_tag == tag: # Inside NE
bio_tagged.append((token, "I-" +tag))
Prev_tag = tag
Elif prev_tag != "O" and prev_tag != tag: # Adjacent NE
bio_tagged.append((token, "B-" +tag))
Prev_tag = tag
Return bio_tagged

Now we write the BIO-tagged tags to the tree, so they are in the same format as the NLTK output.

# Create tree 
def stanford_tree (bio_tagged) :
Tokens, ne_tags = zip(*bio_tagged)
Pos_tags = [pos for token, pos in pos_tag(tokens)]
        Conlltags = [(token, pos, ne) for token, pos, ne in zip(tokens, pos_tags, ne_tags)]
Ne_tree = conlltags2tree(conlltags)
Return ne_tree

Traverse and parse out all named entities:

# Parse named entities from tree 
def structure_ne (ne_tree) :
Ne = []
For subtree in ne_tree:
if type(subtree) == Tree: # If subtree is a noun chunk, ie NE != "O"
Ne_label = subtree.label()
Ne_string = " " .join([token for token, pos in subtree.leaves()])
Ne.append((ne_string, ne_label))
Return ne

In our call, we put all the additional functions together.

Def  stanford_main  () :
Print(structure_ne(stanford_tree(bio_tagger(stanford_tagger(process_text(txt_file)))))))
Def  nltk_main  () : 
print(structure_ne(nltk_tagger(process_text(txt_file))))

Then call these functions:

If __name__ == '__main__' :
Stanford_main()
Nltk_main()

Here is a nice looking output from Stanford:

[('House', 'ORGANIZATION'), ('John Boehner', 'PERSON'), ('Keystone Pipeline', 'ORGANIZATION'), ('Obama', 'PERSON'), ('Republican House', ' ORGANIZATION'), ('John Boehner', 'PERSON'), ('Keystone Pipeline', 'ORGANIZATION'), ('Keystone Pipeline', 'ORGANIZATION'), ('Boehner', 'PERSON'), ('America ', 'LOCATION'), ('United States', 'LOCATION'), ('Keystone Pipeline', 'ORGANIZATION'), ('Keystone Pipeline', 'ORGANIZATION'), ('Boehner', 'PERSON'), ('State Department', 'ORGANIZATION'), ('Republicans', 'MISC'), ('Democratic', 'MISC'), ('GOP', 'MISC'), ('Obama', 'PERSON'), ('White House', 'LOCATION')]

And from NLTK:

[('House', 'ORGANIZATION'), ('John Boehner', 'PERSON'), ('Keystone Pipeline', 'PERSON'), ('Obama', 'ORGANIZATION'), ('Republican', 'ORGANIZATION '), ('House', 'ORGANIZATION'), ('John Boehner', 'PERSON'), ('Keystone Pipeline', 'ORGANIZATION'), ('Keystone Pipeline', 'ORGANIZATION'), ('Boehner' , 'PERSON'), ('America', 'GPE'), ('United States', 'GPE'), ('Keystone Pipeline', 'ORGANIZATION'), ('Listen', 'PERSON'), (' Keystone', 'ORGANIZATION'), ('Boehner', 'PERSON'), ('State Department', 'ORGANIZATION'), ('Democratic', 'ORGANIZATION'), ('GOP', 'ORGANIZATION'), ('Obama', 'PERSON'), ('White House', 'FACILITY')]

Work Hard. God Bless.

Show More

SupportIvy

SupportIvy.com : Un lieu pour partager le savoir et mieux comprendre le monde. Meilleure plate-forme de support gratuit pour vous, Documentation &Tutoriels par les experts.

Related Articles

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Close
Close