TOC

Durchführen einer Stimmungsanalyse in Python 3 mit dem Natural Language Toolkit (NLTK)

Der Autor hat den Fonds Open Internet / Free Speech ausgewählt, um eine Spende im Rahmen von https://do.co/w4do-cta zu erhalten [Write for DOnations] program.

Einführung

Eine große Datenmenge, die heute generiert wird, ist unstructured, für die eine Verarbeitung erforderlich ist, um Erkenntnisse zu generieren. Einige Beispiele für unstrukturierte Daten sind Nachrichtenartikel, Beiträge in sozialen Medien und der Suchverlauf. Der Prozess der Analyse der natürlichen Sprache und ihrer Sinnhaftigkeit fällt in den Bereich der Verarbeitung natürlicher Sprache (Natural Language Processing, NLP). Die Stimmungsanalyse ist eine gängige NLP-Aufgabe, bei der Texte oder Textteile in eine vordefinierte Stimmung eingeteilt werden. Sie verwenden the Natural Language Toolkit (NLTK), eine in Python häufig verwendete NLP-Bibliothek, um Textdaten zu analysieren.

In diesem Lernprogramm bereiten Sie einen Datensatz mit Beispieltweets aus dem NLTK-Paket für NLP mit verschiedenen Datenbereinigungsmethoden vor. Sobald der Datensatz für die Verarbeitung bereit ist, trainieren Sie ein Modell für vorklassifizierte Tweets und klassifizieren die Beispiel-Tweets anhand des Modells in negative und positive Gefühle.

In diesem Artikel wird davon ausgegangen, dass Sie mit den Grundlagen von Python vertraut sind (siehe https://www.digitalocean.com/community/tutorial_series/how-to-code-in-python) -3 [How To Code in Python 3-Serien]), hauptsächlich die Verwendung von Datenstrukturen, Klassen und Methoden. In diesem Tutorial wird davon ausgegangen, dass Sie keine Vorkenntnisse in NLP und "+ nltk +" haben, obwohl einige Kenntnisse darüber von Vorteil sind.

Voraussetzungen

Schritt 1 - NLTK installieren und Daten herunterladen

Sie werden das NLTK-Paket in Python für alle NLP-Aufgaben in diesem Lernprogramm verwenden. In diesem Schritt installieren Sie NLTK und laden die Beispiel-Tweets herunter, mit denen Sie Ihr Modell trainieren und testen.

Zuerst das NLTK-Paket installieren mit dem + pip + Paketmanager:

pip install nltk==3.3

In diesem Tutorial werden Beispiel-Tweets verwendet, die Teil des NLTK-Pakets sind. Starten Sie zunächst eine interaktive Python-Sitzung, indem Sie den folgenden Befehl ausführen:

python3

Importieren Sie dann das + nltk + - Modul in den Python-Interpreter.

import nltk

Laden Sie die Beispiel-Tweets aus dem NLTK-Paket herunter:

nltk.download('twitter_samples')

Wenn Sie diesen Befehl über den Python-Interpreter ausführen, werden die Tweets lokal heruntergeladen und gespeichert. Sobald die Beispiele heruntergeladen wurden, können Sie sie verwenden.

Sie werden die negativen und positiven Tweets verwenden, um Ihr Modell später im Tutorial auf die Stimmungsanalyse zu trainieren. Die Tweets ohne Gefühle werden verwendet, um Ihr Modell zu testen.

Wenn Sie einen eigenen Datensatz verwenden möchten, können Sie über die Twitter API Tweets aus einem bestimmten Zeitraum, Benutzer oder Hashtag sammeln.

Nachdem Sie NLTK importiert und die Beispiel-Tweets heruntergeladen haben, beenden Sie die interaktive Sitzung, indem Sie "+ exit () +" eingeben. Sie können die Tweets importieren und mit der Verarbeitung der Daten beginnen.

Schritt 2 - Tokenisieren der Daten

Die Sprache in ihrer ursprünglichen Form kann von einem Computer nicht genau verarbeitet werden. Sie müssen daher die Sprache verarbeiten, damit der Computer sie besser versteht. Der erste Teil, um die Daten zu verstehen, besteht in einem Prozess, der tokenization genannt wird, oder in der Aufteilung von Zeichenfolgen in kleinere Teile, die tokens genannt werden.

Ein Token ist eine Zeichenfolge im Text, die als Einheit dient. Je nachdem, wie Sie die Token erstellen, können sie aus Wörtern, Emoticons, Hashtags, Links oder sogar einzelnen Zeichen bestehen. Eine grundlegende Möglichkeit, die Sprache in Token zu unterteilen, besteht darin, den Text auf der Grundlage von Leerzeichen und Interpunktion aufzuteilen.

Erstellen Sie zunächst eine neue + .py + - Datei für Ihr Skript. In diesem Tutorial wird "+ nlp_test.py +" verwendet:

nano nlp_test.py

In dieser Datei importieren Sie zuerst die + twitter_samples +, damit Sie mit diesen Daten arbeiten können:

nlp_test.py

from nltk.corpus import twitter_samples

Dadurch werden drei Datensätze aus NLTK importiert, die verschiedene Tweets zum Trainieren und Testen des Modells enthalten:

  • + negative tweets.json: 5000 Tweets mit negativen Gefühlen

  • + positive tweets.json: 5000 Tweets mit positiven Gefühlen

  • + tweets.20150430-223406.json +: 20000 Tweets ohne Gefühle

Als nächstes erstellen Sie Variablen für "+ positive_tweets ", " negative_tweets " und " text +":

nlp_test.py

from nltk.corpus import twitter_samples

Die + strings () + Methode von + twitter_samples + druckt alle Tweets innerhalb eines Datensatzes als Strings. Das Setzen der verschiedenen Tweetsammlungen als Variable erleichtert die Verarbeitung und das Testen.

Bevor Sie einen Tokenizer in NLTK verwenden können, müssen Sie die zusätzliche Ressource "+ punkt " herunterladen. Das ` punkt +` - Modul ist ein vorgefertigtes Modell, mit dessen Hilfe Sie Wörter und Sätze symbolisieren können. Dieses Modell weiß zum Beispiel, dass ein Name einen Punkt enthalten kann (wie „S. Daityari ”) und das Vorhandensein dieser Periode in einem Satz beendet es nicht notwendigerweise. Starten Sie zunächst eine interaktive Python-Sitzung:

python3

Führen Sie die folgenden Befehle in der Sitzung aus, um die Ressource "+ punkt +" herunterzuladen:

import nltk
nltk.download('punkt')

Sobald der Download abgeschlossen ist, können Sie die Tokenizer von NLTK verwenden. NLTK bietet einen Standard-Tokenizer für Tweets mit der Methode + .tokenized () +. Fügen Sie eine Zeile hinzu, um ein Objekt zu erstellen, das das Dataset + positive_tweets.json + tokenisiert:

nlp_test.py

from nltk.corpus import twitter_samples

positive_tweets = twitter_samples.strings('positive_tweets.json')
negative_tweets = twitter_samples.strings('negative_tweets.json')
text = twitter_samples.strings('tweets.20150430-223406.json')

Wenn Sie das Skript testen möchten, um die "+ .tokenized " - Methode in Aktion zu sehen, fügen Sie den hervorgehobenen Inhalt zu Ihrem " nlp_test.py " - Skript hinzu. Dadurch wird ein einzelner Tweet aus dem Datensatz " positive_tweets.json +" markiert:

nlp_test.py

from nltk.corpus import twitter_samples

positive_tweets = twitter_samples.strings('positive_tweets.json')
negative_tweets = twitter_samples.strings('negative_tweets.json')
text = twitter_samples.strings('tweets.20150430-223406.json')
tweet_tokens = twitter_samples.tokenized('positive_tweets.json')

Speichern und schließen Sie die Datei und führen Sie das Skript aus:

python3 nlp_test.py

Der Vorgang der Tokenisierung nimmt einige Zeit in Anspruch, da es sich nicht um eine einfache Aufteilung in Leerzeichen handelt. Nach ein paar Augenblicken sehen Sie Folgendes:

Output['#FollowFriday',
'@France_Inte',
'@PKuchly57',
'@Milipol_Paris',
'for',
'being',
'top',
'engaged',
'members',
'in',
'my',
'community',
'this',
'week',
':)']

Hier gibt die Methode + .tokenized () + Sonderzeichen wie + @ + und + _ + zurück. Diese Zeichen werden später in diesem Lernprogramm durch reguläre Ausdrücke entfernt.

Nachdem Sie gesehen haben, wie die Methode "+ .tokenized () " funktioniert, müssen Sie die letzte Zeile auskommentieren oder entfernen, um den mit einem Token versehenen Tweet aus dem Skript zu drucken, indem Sie ein " # +" an den Anfang von " Linie:

nlp_test.py

from nltk.corpus import twitter_samples

positive_tweets = twitter_samples.strings('positive_tweets.json')
negative_tweets = twitter_samples.strings('negative_tweets.json')
text = twitter_samples.strings('tweets.20150430-223406.json')
tweet_tokens = twitter_samples.tokenized('positive_tweets.json')

#print(tweet_tokens[0])

Ihr Skript ist jetzt so konfiguriert, dass Daten mit einem Token versehen werden. Im nächsten Schritt aktualisieren Sie das Skript, um die Daten zu normalisieren.

Schritt 3 - Normalisieren der Daten

Wörter haben unterschiedliche Formen - zum Beispiel „ran“, „running“ und „running“ sind verschiedene Formen desselben Verbs, „run“. Abhängig von den Anforderungen Ihrer Analyse müssen möglicherweise alle diese Versionen in dieselbe Form, "run" (Ausführen), konvertiert werden. Normalization in NLP ist der Prozess der Konvertierung eines Wortes in seine kanonische Form.

Durch die Normalisierung können Wörter mit derselben Bedeutung, aber unterschiedlichen Formen zusammengefasst werden. Ohne Normalisierung würden "ran", "runs" und "running" als unterschiedliche Wörter behandelt, auch wenn Sie möchten, dass sie als dasselbe Wort behandelt werden. In diesem Abschnitt untersuchen Sie stemming und lemmatization, zwei beliebte Techniken der Normalisierung.

Stemming ist ein Vorgang, bei dem Anhänge aus einem Wort entfernt werden. Stemming, das nur mit einfachen Verbformen arbeitet, ist ein heuristischer Prozess, der die Enden von Wörtern entfernt.

In diesem Tutorial verwenden Sie den Prozess der Lemmatisierung, bei dem ein Wort mit dem Kontext des Wortschatzes und morphological analysis von Wörtern im Text normalisiert wird. Der Lemmatisierungsalgorithmus analysiert die Struktur des Wortes und seinen Kontext, um es in eine normalisierte Form umzuwandeln. Daher ist es mit Geschwindigkeit verbunden. Ein Vergleich von Stemming und Lemmatization führt letztendlich zu einem Kompromiss zwischen Geschwindigkeit und Genauigkeit.

Bevor Sie die Lemmatisierung verwenden, laden Sie die erforderlichen Ressourcen herunter, indem Sie Folgendes in eine interaktive Python-Sitzung eingeben:

python3

Führen Sie in der Sitzung die folgenden Befehle aus, um die Ressourcen herunterzuladen:

import nltk
nltk.download('wordnet')
nltk.download('averaged_perceptron_tagger')

http://www.nltk.org/howto/wordnet.html [+ wordnet +] ist eine lexikalische Datenbank für die englische Sprache, mit deren Hilfe das Skript das Basiswort ermitteln kann. Sie benötigen die Ressource "+ averaged_perceptron_tagger +", um den Kontext eines Wortes in einem Satz zu bestimmen.

Nach dem Herunterladen sind Sie fast bereit, den Lemmatizer zu verwenden. Bevor Sie einen Lemmatizer ausführen, müssen Sie den Kontext für jedes Wort in Ihrem Text bestimmen. Dies wird durch einen Markierungsalgorithmus erreicht, der die relative Position eines Wortes in einem Satz bewertet. Importieren Sie in einer Python-Sitzung die Funktion + pos_tag + und geben Sie eine Liste von Tokens als Argument an, um die Tags abzurufen. Probieren wir das in Python aus:

from nltk.tag import pos_tag
from nltk.corpus import twitter_samples

tweet_tokens = twitter_samples.tokenized('positive_tweets.json')
print(pos_tag(tweet_tokens[0]))

Hier ist die Ausgabe der Funktion + pos_tag +.

Output[('#FollowFriday', 'JJ'),
('@France_Inte', 'NNP'),
('@PKuchly57', 'NNP'),
('@Milipol_Paris', 'NNP'),
('for', 'IN'),
('being', 'VBG'),
('top', 'JJ'),
('engaged', 'VBN'),
('members', 'NNS'),
('in', 'IN'),
('my', 'PRP$'),
('community', 'NN'),
('this', 'DT'),
('week', 'NN'),
(':)', 'NN')]

In der Liste der Tags finden Sie die Liste der am häufigsten verwendeten Elemente und deren Bedeutung:

  • + NNP +: Nomen, Eigenname, Singular

  • + NN +: Nomen, Common, Singular oder Masse

  • + IN +: Präposition oder Konjunktion, untergeordnet

  • + VBG +: Verb, Gerundium oder Partizip Präsens

  • + VBN +: Verb, Partizip Perfekt

Hier ist eine https://www.ling.upenn.edu/courses/Fall_2003/ling001/penn_treebank_pos.html vollständige Liste des Datensatzes].

Wenn ein Tag mit "+ NN " beginnt, ist das Wort ein Substantiv, und wenn es mit " VB " beginnt, ist das Wort ein Verb. Beenden Sie nach dem Überprüfen der Tags die Python-Sitzung, indem Sie " exit () +" eingeben.

Um dies in eine Funktion zu integrieren, die einen Satz normalisiert, sollten Sie zuerst die Tags für jedes Token im Text generieren und dann jedes Wort mithilfe des Tags lemmatisieren.

Aktualisieren Sie die Datei "+ nlp_test.py +" mit der folgenden Funktion, die einen Satz lemmatisiert:

nlp_test.py

...

from nltk.tag import pos_tag
from nltk.stem.wordnet import WordNetLemmatizer

def lemmatize_sentence(tokens):
   lemmatizer = WordNetLemmatizer()
   lemmatized_sentence = []
   for word, tag in pos_tag(tokens):
       if tag.startswith('NN'):
           pos = 'n'
       elif tag.startswith('VB'):
           pos = 'v'
       else:
           pos = 'a'
       lemmatized_sentence.append(lemmatizer.lemmatize(word, pos))
   return lemmatized_sentence

print(lemmatize_sentence(tweet_tokens[0]))

Dieser Code importiert die Klasse "+ WordNetLemmatizer " und initialisiert sie mit der Variablen " lemmatizer +".

Die Funktion "+ lemmatize_sentence " erhält zuerst den Positions-Tag jedes Tokens eines Tweets. Beginnt das Tag in der Anweisung " if " mit " NN ", wird das Token als Substantiv zugewiesen. Wenn das Tag mit " VB +" beginnt, wird das Token ebenfalls als Verb zugewiesen.

Speichern und schließen Sie die Datei und führen Sie das Skript aus:

python3 nlp_test.py

Hier ist die Ausgabe:

Output['#FollowFriday',
'@France_Inte',
'@PKuchly57',
'@Milipol_Paris',
'for',
'be',
'top',
'engage',
'member',
'in',
'my',
'community',
'this',
'week',
':)']

Sie werden bemerken, dass sich das Verb + being + in seine Wurzelform ändert, + be + und das Substantiv + members + sich in + member + ändert. Bevor Sie fortfahren, kommentieren Sie die letzte Zeile aus, die den Beispiel-Tweet aus dem Skript druckt.

Nachdem Sie erfolgreich eine Funktion zum Normalisieren von Wörtern erstellt haben, können Sie mit dem Entfernen von Rauschen fortfahren.

Schritt 4 - Entfernen von Rauschen aus den Daten

In diesem Schritt entfernen Sie Rauschen aus dem Datensatz. Noise ist ein Teil des Textes, der keine Bedeutung oder Information zu Daten hinzufügt.

Lärm ist für jedes Projekt spezifisch. Was also Lärm in einem Projekt ausmacht, darf sich nicht in einem anderen Projekt befinden. Beispielsweise werden die häufigsten Wörter in einer Sprache als Stoppwörter bezeichnet. Einige Beispiele für Stoppwörter sind "is", "the" und "a". Sie sind bei der Verarbeitung der Sprache im Allgemeinen irrelevant, es sei denn, ein spezifischer Anwendungsfall rechtfertigt deren Einbeziehung.

In diesem Lernprogramm verwenden Sie reguläre Ausdrücke in Python, um unter https://docs.python.org/3.6/howto/regex.html nach folgenden Elementen zu suchen und diese zu entfernen:

  • * Hyperlinks * - Alle Hyperlinks in Twitter werden in den URL-Shortener t.co konvertiert. Wenn Sie sie daher in der Textverarbeitung belassen, wird die Analyse keinen Mehrwert erhalten.

  • * Twitter behandelt in Antworten * - Vor diesen Twitter-Benutzernamen steht ein "+ @ +" - Symbol, das keine Bedeutung vermittelt.

  • * Interpunktion und Sonderzeichen * - Während diese häufig Kontext für Textdaten bieten, ist dieser Kontext häufig schwierig zu verarbeiten. Der Einfachheit halber entfernen Sie alle Satzzeichen und Sonderzeichen aus Tweets.

Um Hyperlinks zu entfernen, müssen Sie zuerst nach einer Teilzeichenfolge suchen, die einer URL entspricht, die mit "+ http: // " oder " https: // " beginnt, gefolgt von Buchstaben, Zahlen oder Sonderzeichen. Sobald ein Muster gefunden wurde, wird es durch die Methode " () +" durch eine leere Zeichenfolge ersetzt.

Da wir Wortformen innerhalb der Funktion + remove_noise () + normalisieren, können Sie die Funktion + lemmatize_sentence () + aus dem Skript auskommentieren.

Fügen Sie der Datei + nlp_test.py + den folgenden Code hinzu, um Rauschen aus dem Datensatz zu entfernen:

nlp_test.py

...

import re, string

def remove_noise(tweet_tokens, stop_words = ()):

   cleaned_tokens = []

   for token, tag in pos_tag(tweet_tokens):
       token = re.sub('http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+#]|[!*\(\),]|'\
                      '(?:%[0-9a-fA-F][0-9a-fA-F]))+','', token)
       token = re.sub("(@[A-Za-z0-9_]+)","", token)

       if tag.startswith("NN"):
           pos = 'n'
       elif tag.startswith('VB'):
           pos = 'v'
       else:
           pos = 'a'

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

       if len(token) > 0 and token not in string.punctuation and token.lower() not in stop_words:
           cleaned_tokens.append(token.lower())
   return cleaned_tokens

Dieser Code erstellt eine Funktion + remove_noise () +, die Rauschen entfernt und die im vorherigen Abschnitt erwähnte Normalisierung und Lemmatisierung einbezieht. Der Code verwendet zwei Argumente: die Tweet-Token und das Tupel von Stoppwörtern.

Der Code verwendet dann eine Schleife, um das Rauschen aus dem Datensatz zu entfernen. Um Hyperlinks zu entfernen, sucht der Code zuerst nach einer Teilzeichenfolge, die einer URL entspricht, die mit "+ http: // " oder " https: // " beginnt, gefolgt von Buchstaben, Zahlen oder Sonderzeichen. Sobald ein Muster gefunden wurde, wird es durch die Methode " () " durch eine leere Zeichenfolge oder "" + "ersetzt.

Um "+ @ " - Erwähnungen zu entfernen, ersetzt der Code den relevanten Teil des Textes mit regulären Ausdrücken. Der Code durchsucht die ` re ` Bibliothek nach ` @ ` Symbolen, gefolgt von Zahlen, Buchstaben oder ` _ +` und ersetzt sie durch eine leere Zeichenkette.

Schließlich können Sie die Interpunktion mit der Bibliothek + string + entfernen.

Darüber hinaus entfernen Sie Stoppwörter mithilfe eines integrierten Satzes von Stoppwörtern in NLTK, die separat heruntergeladen werden müssen.

Führen Sie den folgenden Befehl aus einer interaktiven Python-Sitzung aus, um diese Ressource herunterzuladen:

nltk.download('stopwords')

Beenden Sie die interaktive Sitzung, sobald die Ressource heruntergeladen wurde.

Sie können die Methode + .words () + verwenden, um eine Liste der Stoppwörter auf Englisch abzurufen. Um die Funktion zu testen, lassen Sie es uns auf unserem Beispiel-Tweet ausführen. Fügen Sie die folgenden Zeilen am Ende der Datei + nlp_test.py + hinzu:

nlp_test.py

...
from nltk.corpus import stopwords
stop_words = stopwords.words('english')

print(remove_noise(tweet_tokens[0], stop_words))

Führen Sie das Skript nach dem Speichern und Schließen der Datei erneut aus, um eine Ausgabe zu erhalten, die der folgenden ähnelt:

Output['#followfriday', 'top', 'engage', 'member', 'community', 'week', ':)']

Beachten Sie, dass die Funktion alle + @ + Erwähnungen entfernt, Wörter stoppt und die Wörter in Kleinbuchstaben konvertiert.

Bevor Sie im nächsten Schritt mit der Modellierungsübung fortfahren, verwenden Sie die Funktion + remove_noise () +, um die positiven und negativen Tweets zu bereinigen. Kommentieren Sie die Zeile aus, um die Ausgabe von "+ remove_noise () " auf dem Beispiel-Tweet zu drucken, und fügen Sie dem Skript " nlp_test.py +" Folgendes hinzu:

nlp_test.py

...
from nltk.corpus import stopwords
stop_words = stopwords.words('english')

print(remove_noise(tweet_tokens[0], stop_words))

Nachdem Sie den Code zum Bereinigen der Beispiel-Tweets hinzugefügt haben, möchten Sie möglicherweise die ursprünglichen Token mit den bereinigten Token für einen Beispiel-Tweet vergleichen. Wenn Sie dies testen möchten, fügen Sie der Datei den folgenden Code hinzu, um beide Versionen des 500. Tweets in der Liste zu vergleichen:

nlp_test.py

...
print(positive_tweet_tokens[500])
print(positive_cleaned_tokens_list[500])

Speichern und schließen Sie die Datei und führen Sie das Skript aus. In der Ausgabe sehen Sie, dass die Interpunktion und die Links entfernt und die Wörter in Kleinbuchstaben umgewandelt wurden.

Output['Dang', 'that', 'is', 'some', 'rad', '@AbzuGame', '#fanart', '!', ':D', 'https://t.co/bI8k8tb9ht']
['dang', 'rad', '#fanart', ':d']

Es gibt bestimmte Probleme, die bei der Vorverarbeitung von Text auftreten können. Beispielsweise werden Wörter ohne Leerzeichen („iLoveYou“) als eins behandelt, und es kann schwierig sein, solche Wörter zu trennen. Darüber hinaus werden "Hi", "Hii" und "Hiiiii" vom Skript unterschiedlich behandelt, es sei denn, Sie schreiben etwas Spezielles, um das Problem zu lösen. Es ist üblich, den Rauschentfernungsprozess für Ihre spezifischen Daten zu optimieren.

Nachdem Sie die Funktion "+ remove_noise () +" in Aktion gesehen haben, müssen Sie die letzten beiden Zeilen aus dem Skript auskommentieren oder entfernen, damit Sie weitere hinzufügen können:

nlp_test.py

...
print(positive_tweet_tokens[500])
print(positive_cleaned_tokens_list[500])

In diesem Schritt haben Sie Rauschen aus den Daten entfernt, um die Analyse effektiver zu gestalten. Im nächsten Schritt analysieren Sie die Daten, um die häufigsten Wörter in Ihrem Beispieldatensatz zu finden.

Schritt 5 - Bestimmung der Wortdichte

Die grundlegendste Form der Analyse von Textdaten besteht darin, die Worthäufigkeit herauszunehmen. Ein einzelner Tweet ist zu klein für eine Entität, um die Verteilung von Wörtern herauszufinden. Daher würde die Analyse der Häufigkeit von Wörtern für alle positiven Tweets durchgeführt.

Das folgende Snippet definiert a generator function mit dem Namen + get_all_words +, das eine Liste von Tweets als Argument verwendet, um eine Liste von Wörtern in allen von bereitzustellen Die Tweet-Token gesellten sich dazu. Fügen Sie der Datei + nlp_test.py + den folgenden Code hinzu:

nlp_test.py

...

def get_all_words(cleaned_tokens_list):
   for tokens in cleaned_tokens_list:
       for token in tokens:
           yield token

all_pos_words = get_all_words(positive_cleaned_tokens_list)

Nachdem Sie alle Wörter aus dem Tweetsample zusammengestellt haben, können Sie mit http://www.nltk.org/api/nltk.html?highlight=freqdist [+ FreqDist +] herausfinden, welche Wörter am häufigsten vorkommen. Klasse von NLTK. Fügen Sie der Datei + nlp_test.py + den folgenden Code hinzu:

nlp_test.py

from nltk import FreqDist

freq_dist_pos = FreqDist(all_pos_words)
print(freq_dist_pos.most_common(10))

Die Methode + .most_common () + listet die Wörter auf, die in den Daten am häufigsten vorkommen. Speichern und schließen Sie die Datei, nachdem Sie diese Änderungen vorgenommen haben.

Wenn Sie die Datei jetzt ausführen, finden Sie die häufigsten Begriffe in den Daten:

Output[(':)', 3691),
(':-)', 701),
(':d', 658),
('thanks', 388),
('follow', 357),
('love', 333),
('...', 290),
('good', 283),
('get', 263),
('thank', 253)]

Anhand dieser Daten können Sie erkennen, dass Emoticon-Entities einige der häufigsten Bestandteile positiver Tweets bilden. Stellen Sie vor dem Fortfahren mit dem nächsten Schritt sicher, dass Sie die letzte Zeile des Skripts auskommentieren, in der die zehn wichtigsten Token gedruckt werden.

Zusammenfassend gesagt, haben Sie die Tweets aus "+ nltk +" extrahiert, tokenisiert, normalisiert und die Tweets für die Verwendung im Modell bereinigt. Schließlich haben Sie sich auch die Häufigkeit von Tokens in den Daten angesehen und die Häufigkeit der zehn häufigsten Tokens überprüft.

Im nächsten Schritt bereiten Sie Daten für die Stimmungsanalyse vor.

Schritt 6 - Daten für das Modell vorbereiten

Die Stimmungsanalyse ist ein Prozess, bei dem eine Einstellung des Autors zu einem Thema identifiziert wird, über das gerade geschrieben wird. Sie erstellen einen Trainingsdatensatz zum Trainieren eines Modells. Es handelt sich um einen überwachten Lernprozess, bei dem Sie jedem Datensatz ein „Gefühl“ für das Training zuordnen müssen. In diesem Tutorial verwendet Ihr Modell die "positiven" und "negativen" Gefühle.

Die Stimmungsanalyse kann verwendet werden, um Text in verschiedene Stimmungsbilder einzuordnen. Zur Vereinfachung und Verfügbarkeit des Trainingsdatensatzes hilft Ihnen dieses Tutorial, Ihr Modell in nur zwei Kategorien zu trainieren, positiv und negativ.

Ein Modell ist eine Beschreibung eines Systems unter Verwendung von Regeln und Gleichungen. Es kann so einfach sein wie eine Gleichung, die das Gewicht einer Person aufgrund ihrer Größe vorhersagt. Ein Stimmungsanalysemodell, das Sie erstellen, würde Tweets mit einer positiven oder einer negativen Stimmung verknüpfen. Sie müssen Ihren Datensatz in zwei Teile aufteilen. Der erste Teil dient zum Erstellen des Modells, während der nächste Teil die Leistung des Modells testet.

Im Datenvorbereitungsschritt bereiten Sie die Daten für die Stimmungsanalyse vor, indem Sie Token in das Wörterbuchformular konvertieren und die Daten dann für Schulungs- und Testzwecke aufteilen.

Konvertieren von Tokens in ein Wörterbuch

Zunächst bereiten Sie die Daten vor, die in das Modell eingespeist werden sollen. Sie verwenden den Klassifikator Naive Bayes in NLTK, um die Modellierungsübung durchzuführen. Beachten Sie, dass das Modell nicht nur eine Liste von Wörtern in einem Tweet benötigt, sondern ein Python-Wörterbuch mit Wörtern als Schlüsseln und "+ True +" als Werten. Die folgende Funktion bewirkt, dass ein Generator das Format der bereinigten Daten ändert.

Fügen Sie den folgenden Code hinzu, um die Tweets aus einer Liste bereinigter Token in Wörterbücher mit Schlüsseln als Token und "+ True " als Werten zu konvertieren. Die entsprechenden Wörterbücher werden in ` positive_Token_für_Modell ` und ` negative_Token_für_Modell +` gespeichert.

nlp_test.py

...
def get_tweets_for_model(cleaned_tokens_list):
   for tweet_tokens in cleaned_tokens_list:
       yield dict([token, True] for token in tweet_tokens)

positive_tokens_for_model = get_tweets_for_model(positive_cleaned_tokens_list)
negative_tokens_for_model = get_tweets_for_model(negative_cleaned_tokens_list)

Teilen des Datensatzes zum Trainieren und Testen des Modells

Als nächstes müssen Sie die Daten für das Training der Klasse + NaiveBayesClassifier + vorbereiten. Fügen Sie der Datei den folgenden Code hinzu, um die Daten vorzubereiten:

nlp_test.py

...
import random

positive_dataset = [(tweet_dict, "Positive")
                    for tweet_dict in positive_tokens_for_model]

negative_dataset = [(tweet_dict, "Negative")
                    for tweet_dict in negative_tokens_for_model]

dataset = positive_dataset + negative_dataset

random.shuffle(dataset)

train_data = dataset[:7000]
test_data = dataset[7000:]

Dieser Code fügt jedem Tweet ein positives oder negatives Label hinzu. Anschließend wird ein "+ Datensatz +" erstellt, indem die positiven und negativen Tweets zusammengefügt werden.

Standardmäßig enthalten die Daten alle positiven Tweets, gefolgt von allen negativen Tweets. Wenn Sie das Modell trainieren, sollten Sie eine Stichprobe Ihrer Daten bereitstellen, die keine Verzerrung enthält. Um Verzerrungen zu vermeiden, haben Sie Code hinzugefügt, um die Daten mit der Methode "+ .shuffle () " von " random +" zufällig anzuordnen.

Schließlich teilt der Code die gemischten Daten zu Trainings- bzw. Testzwecken in ein Verhältnis von 70:30 auf. Da die Anzahl der Tweets 10000 beträgt, können Sie die ersten 7000 Tweets aus dem gemischten Datensatz zum Trainieren des Modells und die letzten 3000 zum Testen des Modells verwenden.

In diesem Schritt haben Sie die bereinigten Token in ein Wörterbuch konvertiert, das Dataset zufällig gemischt und in Trainings- und Testdaten aufgeteilt.

Schritt 7 - Erstellen und Testen des Modells

Schließlich können Sie die Klasse + NaiveBayesClassifier + verwenden, um das Modell zu erstellen. Verwenden Sie die Methode "+ .train () ", um das Modell zu trainieren, und die Methode " .accuracy () +", um das Modell anhand der Testdaten zu testen.

nlp_test.py

...
from nltk import classify
from nltk import NaiveBayesClassifier
classifier = NaiveBayesClassifier.train(train_data)

print("Accuracy is:", classify.accuracy(classifier, test_data))

print(classifier.show_most_informative_features(10))

Speichern Sie die Datei, schließen Sie sie und führen Sie sie aus, nachdem Sie den Code hinzugefügt haben. Die Ausgabe des Codes sieht wie folgt aus:

OutputAccuracy is: 0.9956666666666667

Most Informative Features
                     :( = True           Negati : Positi =   2085.6 : 1.0
                     :) = True           Positi : Negati =    986.0 : 1.0
                welcome = True           Positi : Negati =     37.2 : 1.0
                 arrive = True           Positi : Negati =     31.3 : 1.0
                    sad = True           Negati : Positi =     25.9 : 1.0
               follower = True           Positi : Negati =     21.1 : 1.0
                    bam = True           Positi : Negati =     20.7 : 1.0
                   glad = True           Positi : Negati =     18.1 : 1.0
                    x15 = True           Negati : Positi =     15.9 : 1.0
              community = True           Positi : Negati =     14.1 : 1.0

Genauigkeit ist definiert als der Prozentsatz der Tweets im Testdatensatz, für den das Modell die Stimmung korrekt vorhersagen konnte. Eine Genauigkeit von 99,5% des Testsatzes ist ziemlich gut.

In der Tabelle mit den informativsten Funktionen zeigt jede Zeile in der Ausgabe das Verhältnis des Auftretens eines Tokens in Tweets mit positiven und negativen Tags im Trainingsdatensatz. Die erste Zeile in den Daten gibt an, dass in allen Tweets, die das Token ": (" enthalten, das Verhältnis von negativen zu positiven Tweets "+ 2085,6 " zu " 1 " betrug. Interessanterweise scheint es in den positiven Datensätzen ein Token mit ": (" zu geben. Sie können sehen, dass die beiden wichtigsten Unterscheidungsmerkmale im Text die Emoticons sind. Außerdem führen Wörter wie " traurig " zu negativen Gefühlen, wohingegen " willkommen " und " froh +" mit positiven Gefühlen verbunden sind.

Als Nächstes können Sie überprüfen, wie sich das Modell bei zufälligen Tweets von Twitter verhält. Fügen Sie diesen Code zur Datei hinzu:

nlp_test.py

...
from nltk.tokenize import word_tokenize

custom_tweet = "I ordered just once from TerribleCo, they screwed up, never used the app again."

custom_tokens = remove_noise(word_tokenize(custom_tweet))

print(classifier.classify(dict([token, True] for token in custom_tokens)))

Mit diesem Code können Sie benutzerdefinierte Tweets testen, indem Sie die Zeichenfolge aktualisieren, die der Variablen "+ custom_tweet +" zugeordnet ist. Speichern und schließen Sie die Datei, nachdem Sie diese Änderungen vorgenommen haben.

Führen Sie das Skript aus, um den benutzerdefinierten Text zu analysieren. Hier ist die Ausgabe für den benutzerdefinierten Text im Beispiel:

Output'Negative'

Sie können auch überprüfen, ob positive Tweets korrekt gekennzeichnet sind:

nlp_test.py

...
custom_tweet = ''

Hier ist die Ausgabe:

Output'Positive'

Nachdem Sie sowohl positive als auch negative Gefühle getestet haben, aktualisieren Sie die Variable, um ein komplexeres Gefühl wie Sarkasmus zu testen.

nlp_test.py

...
custom_tweet = ''

Hier ist die Ausgabe:

Output'Positive'

Das Modell stufte dieses Beispiel als positiv ein. Dies liegt daran, dass die Trainingsdaten nicht umfassend genug waren, um sarkastische Tweets als negativ einzustufen. Wenn Sie möchten, dass Ihr Modell Sarkasmus vorhersagt, müssen Sie eine ausreichende Menge an Trainingsdaten bereitstellen, um ihn entsprechend zu trainieren.

In diesem Schritt haben Sie das Modell erstellt und getestet. Sie haben auch einige seiner Einschränkungen untersucht, z. B. das Nicht-Erkennen von Sarkasmus in bestimmten Beispielen. Ihr vollständiger Code enthält noch Artefakte. Im nächsten Schritt werden Sie durch die Ausrichtung des Codes an den Best Practices von Python geführt.

Schritt 8 - Bereinigen des Codes (optional)

Obwohl Sie das Lernprogramm abgeschlossen haben, wird empfohlen, den Code in der Datei "+ nlp_test.py +" neu zu organisieren, um die besten Programmiermethoden zu befolgen. Laut Best Practice sollte Ihr Code diese Kriterien erfüllen:

  • Alle Importe sollten am Anfang der Datei stehen. Importe aus derselben Bibliothek sollten in einer einzigen Anweisung zusammengefasst werden.

  • Alle Funktionen sollten nach dem Import definiert werden.

  • Alle Anweisungen in der Datei sollten unter der Bedingung + if name ==" main ": + gespeichert werden. Dadurch wird sichergestellt, dass die Anweisungen nicht ausgeführt werden, wenn Sie die Funktionen der Datei in eine andere Datei importieren.

Wir werden auch den Code entfernen, der auskommentiert wurde, indem wir dem Tutorial zusammen mit der Funktion "+ lemmatize_sentence " folgen, da die Lemmatisierung durch die neue Funktion " remove_noise +" abgeschlossen wird.

Hier ist die bereinigte Version von + nlp_test.py +:

from nltk.stem.wordnet import WordNetLemmatizer
from nltk.corpus import twitter_samples, stopwords
from nltk.tag import pos_tag
from nltk.tokenize import word_tokenize
from nltk import FreqDist, classify, NaiveBayesClassifier

import re, string, random

def remove_noise(tweet_tokens, stop_words = ()):

   cleaned_tokens = []

   for token, tag in pos_tag(tweet_tokens):
       token = re.sub('http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+#]|[!*\(\),]|'\
                      '(?:%[0-9a-fA-F][0-9a-fA-F]))+','', token)
       token = re.sub("(@[A-Za-z0-9_]+)","", token)

       if tag.startswith("NN"):
           pos = 'n'
       elif tag.startswith('VB'):
           pos = 'v'
       else:
           pos = 'a'

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

       if len(token) > 0 and token not in string.punctuation and token.lower() not in stop_words:
           cleaned_tokens.append(token.lower())
   return cleaned_tokens

def get_all_words(cleaned_tokens_list):
   for tokens in cleaned_tokens_list:
       for token in tokens:
           yield token

def get_tweets_for_model(cleaned_tokens_list):
   for tweet_tokens in cleaned_tokens_list:
       yield dict([token, True] for token in tweet_tokens)

if __name__ == "__main__":

   positive_tweets = twitter_samples.strings('positive_tweets.json')
   negative_tweets = twitter_samples.strings('negative_tweets.json')
   text = twitter_samples.strings('tweets.20150430-223406.json')
   tweet_tokens = twitter_samples.tokenized('positive_tweets.json')[0]

   stop_words = stopwords.words('english')

   positive_tweet_tokens = twitter_samples.tokenized('positive_tweets.json')
   negative_tweet_tokens = twitter_samples.tokenized('negative_tweets.json')

   positive_cleaned_tokens_list = []
   negative_cleaned_tokens_list = []

   for tokens in positive_tweet_tokens:
       positive_cleaned_tokens_list.append(remove_noise(tokens, stop_words))

   for tokens in negative_tweet_tokens:
       negative_cleaned_tokens_list.append(remove_noise(tokens, stop_words))

   all_pos_words = get_all_words(positive_cleaned_tokens_list)

   freq_dist_pos = FreqDist(all_pos_words)
   print(freq_dist_pos.most_common(10))

   positive_tokens_for_model = get_tweets_for_model(positive_cleaned_tokens_list)
   negative_tokens_for_model = get_tweets_for_model(negative_cleaned_tokens_list)

   positive_dataset = [(tweet_dict, "Positive")
                        for tweet_dict in positive_tokens_for_model]

   negative_dataset = [(tweet_dict, "Negative")
                        for tweet_dict in negative_tokens_for_model]

   dataset = positive_dataset + negative_dataset

   random.shuffle(dataset)

   train_data = dataset[:7000]
   test_data = dataset[7000:]

   classifier = NaiveBayesClassifier.train(train_data)

   print("Accuracy is:", classify.accuracy(classifier, test_data))

   print(classifier.show_most_informative_features(10))

   custom_tweet = "I ordered just once from TerribleCo, they screwed up, never used the app again."

   custom_tokens = remove_noise(word_tokenize(custom_tweet))

   print(custom_tweet, classifier.classify(dict([token, True] for token in custom_tokens)))

Fazit

Dieses Tutorial führte Sie in ein grundlegendes Stimmungsanalysemodell ein, das die + nltk + - Bibliothek in Python 3 verwendet. Zunächst haben Sie Tweets vorverarbeitet, indem Sie einen Tweet mit einem Token versehen, die Wörter normalisiert und Rauschen entfernt haben. Als Nächstes haben Sie häufig vorkommende Elemente in den Daten visualisiert. Schließlich haben Sie ein Modell erstellt, um einem bestimmten Gefühl Tweets zuzuordnen.

Ein betreutes Lernmodell ist nur so gut wie seine Trainingsdaten. Um das Modell weiter zu stärken, können Sie erwägen, weitere Kategorien wie Aufregung und Wut hinzuzufügen. In diesem Tutorial haben Sie die Oberfläche nur durch Erstellen eines rudimentären Modells zerkratzt. Hier finden Sie unter https://monkeylearn.com/sentiment-analysis/ einen detaillierten Leitfaden zu verschiedenen Überlegungen, auf die Sie bei der Durchführung der Stimmungsanalyse achten müssen.

Related