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

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

Uitgang:

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  (  '  n  Logistic 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  (  '  n  Sample 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