Twitter Sentiment Analysis er processen med at bruge Python til automatisk at forstå de følelser eller meninger, der udtrykkes i tweets. Ved at analysere teksten kan vi klassificere tweets som positive negative eller neutrale. Dette hjælper virksomheder og forskere med at spore offentligt humør brands omdømme eller reaktioner på begivenheder i realtid. Python-biblioteker som TextBlob Tweepy og NLTK gør det nemt at indsamle tweets, der behandler teksten og udfører sentimentanalyse effektivt.

Hvordan er Twitter-stemningsanalyse nyttig?

• Twitter Sentiment Analysis er vigtig, fordi den hjælper folk og virksomheder med at forstå, hvad offentligheden tænker i realtid.
• Millioner af tweets sendes hver dag, hvor de deler meninger om brands produkters begivenheder eller sociale problemer. Ved at analysere denne enorme strøm af data kan virksomheder måle kundetilfredshed spot trends tidligt håndtere negativ feedback hurtigt og træffe bedre beslutninger baseret på hvordan folk rent faktisk har det.
• Det er også nyttigt for forskere og regeringer at overvåge offentlig stemning under valgkriser eller store begivenheder, da det forvandler rå tweets til værdifuld indsigt.

Trin for trin implementering

Trin 1: Installer nødvendige biblioteker

Denne blok installerer og importerer de nødvendige biblioteker. Det bruger pandaer at indlæse og håndtere data TfidfVectorizer at omdanne tekst til tal og scikit lære at træne model.

   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   

Trin 2: Indlæs datasæt

• Her indlæser vi Sentiment140 datasæt fra en zippet CSV-fil kan du downloade den fra Kaggle.
• Vi beholder kun polaritet og tweet-tekstkolonner omdøber dem for klarhedens skyld og udskriver de første par rækker for at kontrollere 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  ())   

Produktion:

Trin 3: Behold kun positive og negative følelser

• Her fjerner vi neutrale tweets, hvor polariteten er 2 kortlægger etiketterne, så 0 forbliver negativ og 4 bliver 1 for positiv.
• Derefter udskriver vi, hvor mange positive og negative tweets, der er tilbage i dataene.

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

Produktion:

Trin 4: Rens tweets

• Her definerer vi en simpel funktion til at konvertere al tekst til små bogstaver for konsistens, anvender den på hvert tweet i datasættet.
• Viser derefter de originale og rensede versioner af de første par tweets.

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

Produktion:

Trin 5: Train Test Split

• Denne kode opdeler clean_text- og polaritetskolonnerne i trænings- og testsæt ved hjælp af en 80/20-deling.
• random_state=42 sikrer reproducerbarhed.

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

Produktion:

Togstørrelse: 1280000
Teststørrelse: 320000

Trin 6: Udfør vektorisering

• Denne kode skaber en TF IDF vectorizer, der konverterer tekst til numeriske funktioner ved hjælp af unigrammer og bigrammer begrænset til 5000 funktioner.
• Den tilpasser og transformerer træningsdataene og transformerer testdataene og udskriver derefter formerne af de resulterende TF IDF-matricer.

   vectorizer   =   TfidfVectorizer  (  max_features  =  5000     ngram_range  =  (  1    2  ))   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  )   

Produktion:

TF-IDF form (tog): (1280000 5000)
TF-IDF form (test): (320000 5000)

Trin 7: Træn Bernoulli Naive Bayes model

• Her træner vi en Bernoulli Naive Bayes klassificerer på TF IDF-funktionerne fra træningsdataene.
• Den forudsiger følelser for testdataene og udskriver derefter nøjagtigheden og en detaljeret klassificeringsrapport.

   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  (  '  n  BernoulliNB Classification Report:  n  '     classification_report  (  y_test     bnb_pred  ))   

Produktion:

Trin 9: Træn Support Vector Machine (SVM) model

• Denne kode træner en Support Vector Machine (SVM) med maksimalt 1000 iterationer på TF IDF-funktionerne.
• Den forudsiger testetiketter og udskriver derefter nøjagtigheden og en detaljeret klassificeringsrapport, der viser, hvor godt SVM'en klarede sig.

   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  (  '  n  SVM Classification Report:  n  '     classification_report  (  y_test     svm_pred  ))   

Produktion:

Trin 10: Træn logistisk regressionsmodel

• Denne kode træner en Logistisk regression model med op til 100 iterationer på TF IDF-funktionerne.
• Den forudsiger sentimentetiketter for testdataene og udskriver nøjagtigheden og den detaljerede klassificeringsrapport til modelevaluering.

   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  (  '  n  Logistic Regression Classification Report:  n  '     classification_report  (  y_test     logreg_pred  ))   

Produktion:

Trin 11: Lav forudsigelser på eksempel-tweets

• Denne kode tager tre eksempler på tweets og transformerer dem til TF IDF-funktioner ved hjælp af den samme vektorizer.
• Den forudsiger derefter deres følelser ved hjælp af de trænede BernoulliNB SVM- og Logistic Regression-modeller og udskriver resultaterne for hver klassifikator.
• Hvor 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  (  '  n  Sample Predictions:'  )   print  (  'BernoulliNB:'       bnb  .  predict  (  sample_vec  ))   print  (  'SVM:'       svm  .  predict  (  sample_vec  ))   print  (  'Logistic Regression:'       logreg  .  predict  (  sample_vec  ))   

Produktion:

Vi kan se, at vores modeller fungerer fint og giver de samme forudsigelser selv med forskellige tilgange.

Du kan downloade kildekoden herfra- Twitter-stemningsanalyse ved hjælp af Python