Bei der Twitter-Sentimentanalyse wird Python verwendet, um die in Tweets zum Ausdruck gebrachten Emotionen oder Meinungen automatisch zu verstehen. Durch die Analyse des Textes können wir Tweets als positiv, negativ oder neutral klassifizieren. Dies hilft Unternehmen und Forschern, die öffentliche Stimmung, den Ruf einer Marke oder Reaktionen auf Ereignisse in Echtzeit zu verfolgen. Python-Bibliotheken wie TextBlob Tweepy und NLTK machen es einfach, Tweets zu sammeln, den Text zu verarbeiten und eine Stimmungsanalyse effizient durchzuführen.

Wie ist die Twitter-Sentiment-Analyse nützlich?

• Täglich werden Millionen von Tweets gepostet, in denen Meinungen zu Marken, Produkten, Veranstaltungen oder sozialen Themen ausgetauscht werden. Durch die Analyse dieses riesigen Datenstroms können Unternehmen frühzeitig Trends bei der Kundenzufriedenheit erkennen, mit negativem Feedback schnell umgehen und bessere Entscheidungen auf der Grundlage der tatsächlichen Gefühle der Menschen treffen.
• Es ist auch für Forscher und Regierungen nützlich, die öffentliche Stimmung während Wahlkrisen oder Großveranstaltungen zu überwachen, da es rohe Tweets in wertvolle Erkenntnisse umwandelt.

Schritt-für-Schritt-Implementierung

Schritt 1: Erforderliche Bibliotheken installieren

Dieser Block installiert und importiert die erforderlichen Bibliotheken. Es nutzt Pandas zum Laden und Bearbeiten von Daten TfidfVectorizer Text in Zahlen umwandeln und scikit lernen Modell trainieren.

pip install pandas scikit-learn import pandas as pd from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.model_selection import train_test_split from sklearn.naive_bayes import BernoulliNB from sklearn.linear_model import LogisticRegression from sklearn.svm import LinearSVC from sklearn.metrics import accuracy_score classification_report 

Schritt 2: Datensatz laden

• Hier laden wir die Sentiment140-Datensatz aus einer gezippten CSV-Datei können Sie bei Kaggle herunterladen.
• Wir behalten nur die Polaritäts- und Tweet-Textspalten bei, benennen sie aus Gründen der Übersichtlichkeit um und drucken die ersten paar Zeilen aus, um die Daten zu überprüfen.

df = pd.read_csv('training.1600000.processed.noemoticon.csv.zip' encoding='latin-1' header=None) df = df[[0 5]] df.columns = ['polarity' 'text'] print(df.head()) 

Ausgabe:

Schritt 3: Behalten Sie nur positive und negative Gefühle bei

• Hier entfernen wir neutrale Tweets, bei denen die Polarität 2 ist. Ordnen Sie die Beschriftungen so zu, dass 0 negativ bleibt und 4 zu 1 für positiv wird.
• Dann drucken wir aus, wie viele positive und negative Tweets noch in den Daten enthalten sind.

df = df[df.polarity != 2] df['polarity'] = df['polarity'].map({0: 0 4: 1}) print(df['polarity'].value_counts()) 

Ausgabe:

Schritt 4: Bereinigen Sie die Tweets

• Hier definieren wir eine einfache Funktion, um aus Konsistenzgründen den gesamten Text in Kleinbuchstaben umzuwandeln und ihn auf jeden Tweet im Datensatz anzuwenden.
• Zeigt dann die Original- und bereinigten Versionen der ersten paar Tweets.

def clean_text(text): return text.lower() df['clean_text'] = df['text'].apply(clean_text) print(df[['text' 'clean_text']].head()) 

Ausgabe:

Schritt 5: Trainieren Sie die Testaufteilung

• Dieser Code teilt die Spalten „clean_text“ und „polarity“ im Verhältnis 80/20 in Trainings- und Testsätze auf.
• random_state=42 gewährleistet die Reproduzierbarkeit.

X_train X_test y_train y_test = train_test_split( df['clean_text'] df['polarity'] test_size=0.2 random_state=42 ) print('Train size:' len(X_train)) print('Test size:' len(X_test)) 

Ausgabe:

Zuggröße: 1280000
Testgröße: 320000

Schritt 6: Vektorisierung durchführen

• Dieser Code erstellt einen TF-IDF-Vektorisierer, der Text mithilfe von auf 5000 Features begrenzten Unigrammen und Bigrammen in numerische Features umwandelt.
• Es passt die Trainingsdaten an und transformiert sie, transformiert die Testdaten und druckt dann die Formen der resultierenden TF-IDF-Matrizen.

vectorizer = TfidfVectorizer(max_features=5000 ngram_range=(12)) X_train_tfidf = vectorizer.fit_transform(X_train) X_test_tfidf = vectorizer.transform(X_test) print('TF-IDF shape (train):' X_train_tfidf.shape) print('TF-IDF shape (test):' X_test_tfidf.shape) 

Ausgabe:

TF-IDF-Form (Zug): (1280000 5000)
TF-IDF-Form (Test): (320000 5000)

Schritt 7: Trainieren Sie das Bernoulli Naive Bayes-Modell

• Hier trainieren wir a Bernoulli Naive Bayes Klassifikator für die TF-IDF-Funktionen aus den Trainingsdaten.
• Es prognostiziert Stimmungen für die Testdaten und druckt dann die Genauigkeit und einen detaillierten Klassifizierungsbericht aus.

bnb = BernoulliNB() bnb.fit(X_train_tfidf y_train) bnb_pred = bnb.predict(X_test_tfidf) print('Bernoulli Naive Bayes Accuracy:' accuracy_score(y_test bnb_pred)) print('nBernoulliNB Classification Report:n' classification_report(y_test bnb_pred)) 

Ausgabe:

Schritt 9: Trainieren Sie das SVM-Modell (Support Vector Machine).

• Dieser Code trainiert a Support Vector Machine (SVM) mit maximal 1000 Iterationen der TF IDF-Funktionen.
• Es prognostiziert Testetiketten und druckt dann die Genauigkeit und einen detaillierten Klassifizierungsbericht aus, der die Leistung des SVM zeigt.

svm = LinearSVC(max_iter=1000) svm.fit(X_train_tfidf y_train) svm_pred = svm.predict(X_test_tfidf) print('SVM Accuracy:' accuracy_score(y_test svm_pred)) print('nSVM Classification Report:n' classification_report(y_test svm_pred)) 

Ausgabe:

statisches Schlüsselwort in Java

Schritt 10: Trainieren Sie das logistische Regressionsmodell

• Dieser Code trainiert a Logistische Regression Modell mit bis zu 100 Iterationen der TF-IDF-Funktionen.
• Es prognostiziert Stimmungsbezeichnungen für die Testdaten und druckt den Genauigkeits- und detaillierten Klassifizierungsbericht zur Modellbewertung aus.

logreg = LogisticRegression(max_iter=100) logreg.fit(X_train_tfidf y_train) logreg_pred = logreg.predict(X_test_tfidf) print('Logistic Regression Accuracy:' accuracy_score(y_test logreg_pred)) print('nLogistic Regression Classification Report:n' classification_report(y_test logreg_pred)) 

Ausgabe:

Schritt 11: Treffen Sie Vorhersagen anhand von Beispiel-Tweets

• Dieser Code nimmt drei Beispiel-Tweets und wandelt sie mit demselben Vektorisierer in TF-IDF-Features um.
• Anschließend wird ihre Stimmung mithilfe der trainierten BernoulliNB-SVM- und logistischen Regressionsmodelle vorhergesagt und die Ergebnisse für jeden Klassifikator ausgedruckt.
• Dabei steht 1 für Positiv und 0 für Negativ.

sample_tweets = ['I love this!' 'I hate that!' 'It was okay not great.'] sample_vec = vectorizer.transform(sample_tweets) print('nSample Predictions:') print('BernoulliNB:' bnb.predict(sample_vec)) print('SVM:' svm.predict(sample_vec)) print('Logistic Regression:' logreg.predict(sample_vec)) 

Ausgabe:

Wir können sehen, dass unsere Modelle gut funktionieren und auch mit unterschiedlichen Ansätzen die gleichen Vorhersagen liefern.

Sie können den Quellcode hier herunterladen. Twitter-Sentiment-Analyse mit Python