Twitter Sentiment Analysis er prosessen med å bruke Python til å automatisk forstå følelsene eller meningene som uttrykkes i tweets. Ved å analysere teksten kan vi klassifisere tweets som positive negative eller nøytrale. Dette hjelper bedrifter og forskere med å spore merkevarens omdømme eller reaksjoner på hendelser i sanntid. Python-biblioteker som TextBlob Tweepy og NLTK gjør det enkelt å samle tweets behandle teksten og utføre sentimentanalyse effektivt.

Hvordan er Twitter-sentimentanalyse nyttig?

• Twitter Sentiment Analysis er viktig fordi det hjelper folk og bedrifter å forstå hva publikum tenker i sanntid.
• Millioner av tweets legges ut hver dag og deler meninger om merkevare-produkter eller sosiale problemer. Ved å analysere denne enorme strømmen av data kan bedrifter måle kundetilfredshet oppdage trender tidlig, håndtere negative tilbakemeldinger raskt og ta bedre beslutninger basert på hvordan folk faktisk har det.
• Det er også nyttig for forskere og myndigheter å overvåke offentlig stemning under valgkriser eller store begivenheter, da det gjør rå tweets til verdifull innsikt.

Trinn for trinn implementering

Trinn 1: Installer nødvendige biblioteker

Denne blokken installerer og importerer de nødvendige bibliotekene. Den bruker pandaer å laste og håndtere data TfidfVectorizer å gjøre tekst om til tall og sikit lære å trene modell.

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 

Trinn 2: Last inn datasett

• Her laster vi inn Sentiment140 datasett fra en zippet CSV-fil kan du laste den ned fra Kaggle.
• Vi beholder bare polariteten og tweet-tekstkolonnene gir dem nytt navn for klarhet og skriver ut de første radene for å sjekke dataene.

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

Produksjon:

Trinn 3: Behold bare positive og negative følelser

• Her fjerner vi nøytrale tweets der polariteten er 2 kartlegger etikettene slik at 0 forblir negativ og 4 blir 1 for positiv.
• Deretter skriver vi ut hvor mange positive og negative tweets som er igjen i dataene.

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

Produksjon:

Trinn 4: Rengjør tweetene

• Her definerer vi en enkel funksjon for å konvertere all tekst til små bokstaver for konsistens, bruker den på hver tweet i datasettet.
• Deretter viser de originale og rensede versjonene av de første par tweetene.

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

Produksjon:

Trinn 5: Train Test Split

• Denne koden deler ren_tekst- og polaritetskolonnene inn i trenings- og testsett ved å bruke en 80/20-deling.
• random_state=42 sikrer reproduserbarhet.

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

Produksjon:

Togstørrelse: 1280000
Teststørrelse: 320 000

Trinn 6: Utfør vektorisering

• Denne koden lager en TF IDF-vektorisering som konverterer tekst til numeriske funksjoner ved å bruke unigram og bigram begrenset til 5000 funksjoner.
• Den passer og transformerer treningsdataene og transformerer testdataene og skriver deretter ut formene til de resulterende TF IDF-matrisene.

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) 

Produksjon:

TF-IDF form (tog): (1280000 5000)
TF-IDF form (test): (320 000 5000)

Trinn 7: Tren Bernoulli Naive Bayes-modell

• Her trener vi a Bernoulli Naive Bayes klassifiserer på TF IDF-funksjonene fra treningsdataene.
• Den forutsier sentimenter for testdataene og skriver deretter ut nøyaktigheten og en detaljert klassifiseringsrapport.

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

Produksjon:

Trinn 9: Train Support Vector Machine (SVM) modell

• Denne koden trener en Support Vector Machine (SVM) med maksimalt 1000 iterasjoner på TF IDF-funksjonene.
• Den forutsier testetiketter og skriver deretter ut nøyaktigheten og en detaljert klassifiseringsrapport som viser hvor godt SVM presterte.

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

Produksjon:

np.hvor

Trinn 10: Tren logistisk regresjonsmodell

• Denne koden trener en Logistisk regresjon modell med opptil 100 iterasjoner på TF IDF-funksjonene.
• Den forutsier sentimentetiketter for testdataene og skriver ut nøyaktigheten og den detaljerte klassifiseringsrapporten for modellevaluering.

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

Produksjon:

Trinn 11: Lag spådommer på eksempel Tweets

• Denne koden tar tre eksempler på tweets og forvandler dem til TF IDF-funksjoner ved å bruke den samme vektoriseringen.
• Den forutsier deretter følelsene deres ved å bruke de trente BernoulliNB SVM- og Logistic Regression-modellene og skriver ut resultatene for hver klassifiserer.
• Der 1 står for positiv og 0 for 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)) 

Produksjon:

Vi kan se at modellene våre fungerer bra og gir samme spådommer selv med forskjellige tilnærminger.

Du kan laste ned kildekoden herfra- Twitter-sentimentanalyse ved hjelp av Python