Twitter Sentiment Analyse is het proces waarbij Python wordt gebruikt om de emoties of meningen die in tweets worden geuit automatisch te begrijpen. Door de tekst te analyseren kunnen we tweets classificeren als positief negatief of neutraal. Dit helpt bedrijven en onderzoekers om de reputatie van het publieke merk of de reacties op gebeurtenissen in realtime te volgen. Python-bibliotheken zoals TextBlob Tweepy en NLTK maken het eenvoudig om tweets te verzamelen, de tekst te verwerken en sentimentanalyse efficiënt uit te voeren.

Hoe is Twitter-sentimentanalyse nuttig?

• Twitter-sentimentanalyse is belangrijk omdat het mensen en bedrijven helpt te begrijpen wat het publiek in realtime denkt.
• Elke dag worden er miljoenen tweets geplaatst waarin meningen worden gedeeld over merkproducten, evenementen of sociale kwesties. Door deze enorme stroom aan gegevens te analyseren, kunnen bedrijven de klanttevredenheid meten en trends in een vroeg stadium ontdekken, negatieve feedback snel verwerken en betere beslissingen nemen op basis van hoe mensen zich daadwerkelijk voelen.
• Het is ook nuttig voor onderzoekers en overheden om de publieke stemming te volgen tijdens verkiezingscrises of grote evenementen, omdat het rauwe tweets omzet in waardevolle inzichten.

Stap voor stap implementatie

Stap 1: Installeer de benodigde bibliotheken

Dit blok installeert en importeert de vereiste bibliotheken. Het gebruikt panda's om gegevens te laden en te verwerken TfidfVectorizer om tekst in cijfers om te zetten en scikit leren model te trainen.

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 

Stap 2: Gegevensset laden

• Hier laden we de Sentiment140-gegevensset vanuit een gecomprimeerd CSV-bestand kunt u het downloaden van Kaggle.
• We behouden alleen de polariteit en tweettekstkolommen, hernoemen ze voor de duidelijkheid en drukken de eerste paar rijen af ​​om de gegevens te controleren.

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()) 

Uitgang:

Stap 3: Bewaar alleen positieve en negatieve gevoelens

• Hier verwijderen we neutrale tweets waarbij de polariteit 2 is en brengen de labels in kaart, zodat 0 negatief blijft en 4 1 wordt voor positief.
• Vervolgens printen we hoeveel positieve en negatieve tweets er nog in de data zitten.

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

Uitgang:

Stap 4: Maak de tweets schoon

• Hier definiëren we een eenvoudige functie om alle tekst naar kleine letters te converteren voor consistentie en deze op elke tweet in de dataset toe te passen.
• Toont vervolgens de originele en opgeschoonde versies van de eerste paar tweets.

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

Uitgang:

Stap 5: Treintestsplitsing

• Deze code splitst de kolommen clean_text en polarity op in trainings- en testsets met behulp van een 80/20-verdeling.
• random_state=42 zorgt voor reproduceerbaarheid.

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)) 

Uitgang:

Treingrootte: 1280000
Testgrootte: 320000

Stap 6: Voer vectorisatie uit

• Deze code creëert een TF IDF-vectorizer die tekst omzet in numerieke kenmerken met behulp van unigrammen en bigrams die beperkt zijn tot 5000 kenmerken.
• Het past en transformeert de trainingsgegevens en transformeert de testgegevens en drukt vervolgens de vormen van de resulterende TF IDF-matrices af.

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) 

Uitgang:

TF-IDF-vorm (trein): (1280000 5000)
TF-IDF-vorm (test): (320000 5000)

Stap 7: Train het Bernoulli Naive Bayes-model

• Hier trainen wij A Bernoulli Naïeve Bayes classifier op de TF IDF-functies uit de trainingsgegevens.
• Het voorspelt sentimenten voor de testgegevens en drukt vervolgens de nauwkeurigheid en een gedetailleerd classificatierapport af.

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)) 

Uitgang:

Stap 9: Train Support Vector Machine (SVM)-model

• Deze code traint a Ondersteuningsvectormachine (SVM) met een maximum van 1000 iteraties op de TF IDF-functies.
• Het voorspelt testlabels en drukt vervolgens de nauwkeurigheid af, evenals een gedetailleerd classificatierapport dat laat zien hoe goed de SVM heeft gepresteerd.

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)) 

Uitgang:

Python nieuwe regel

Stap 10: Train het logistieke regressiemodel

• Deze code traint a Logistieke regressie model met maximaal 100 iteraties op de TF IDF-functies.
• Het voorspelt sentimentlabels voor de testgegevens en drukt het nauwkeurigheids- en gedetailleerde classificatierapport af voor modelevaluatie.

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)) 

Uitgang:

Stap 11: Maak voorspellingen op basis van voorbeeldtweets

• Deze code neemt drie voorbeeldtweets en transformeert deze in TF IDF-functies met behulp van dezelfde vectorizer.
• Vervolgens voorspelt het hun sentiment met behulp van de getrainde BernoulliNB SVM- en logistieke regressiemodellen en worden de resultaten voor elke classificator afgedrukt.
• Waarbij 1 staat voor Positief en 0 voor Negatief.

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)) 

Uitgang:

We kunnen zien dat onze modellen prima werken en dezelfde voorspellingen geven, zelfs met verschillende benaderingen.

U kunt de broncode hier downloaden- Twitter-sentimentanalyse met Python