Twitter Sentiment Analysis är processen att använda Python för att automatiskt förstå de känslor eller åsikter som uttrycks i tweets. Genom att analysera texten kan vi klassificera tweets som positiva negativa eller neutrala. Detta hjälper företag och forskare att spåra det offentliga varumärkets rykte eller reaktioner på händelser i realtid. Python-bibliotek som TextBlob Tweepy och NLTK gör det enkelt att samla in tweets bearbeta texten och utföra sentimentanalys effektivt.

Hur är Twitter-sentimentanalys användbar?

• Twitter Sentiment Analysis är viktigt eftersom det hjälper människor och företag att förstå vad allmänheten tycker i realtid.
• Miljontals tweets läggs upp varje dag som delar åsikter om varumärkesprodukter eller sociala frågor. Genom att analysera denna enorma dataström kan företag mäta kundnöjdhet upptäcka trender tidigt hantera negativ feedback snabbt och fatta bättre beslut baserat på hur människor faktiskt känner.
• Det är också användbart för forskare och regeringar att övervaka allmänhetens stämning under valkriser eller stora evenemang eftersom det förvandlar råa tweets till värdefulla insikter.

Steg för steg implementering

Steg 1: Installera nödvändiga bibliotek

Detta block installerar och importerar de nödvändiga biblioteken. Den använder pandor att ladda och hantera data TfidfVectorizer att förvandla text till siffror och scikit lära sig att träna 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   

Steg 2: Ladda datauppsättning

• Här laddar vi Sentiment140 dataset från en zippad CSV-fil kan du ladda ner den från Kaggle.
• Vi behåller bara polariteten och tweettextkolumnerna byter namn på dem för tydlighetens skull och skriver ut de första raderna för att kontrollera data.

   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:

Steg 3: Behåll endast positiva och negativa känslor

• Här tar vi bort neutrala tweets där polariteten är 2 mappar etiketterna så 0 förblir negativ och 4 blir 1 för positiv.
• Sedan skriver vi ut hur många positiva och negativa tweets som finns kvar i datan.

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

Produktion:

Steg 4: Rengör tweets

• Här definierar vi en enkel funktion för att konvertera all text till gemener för konsekvens tillämpar den på varje tweet i datamängden.
• Visar sedan de ursprungliga och rensade versionerna av de första tweetarna.

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

Produktion:

Steg 5: Tågtestdelning

• Denna kod delar upp kolumnerna clean_text och polaritet i tränings- och testuppsättningar med en 80/20-delning.
• random_state=42 säkerställer reproducerbarhet.

   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:

Tågstorlek: 1280000
Teststorlek: 320 000

Steg 6: Utför vektorisering

• Den här koden skapar en TF IDF-vektoriserare som konverterar text till numeriska funktioner med hjälp av unigram och bigram begränsade till 5000 funktioner.
• Den passar och transformerar träningsdata och transformerar testdata och skriver sedan ut formerna på de resulterande TF IDF-matriserna.

   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 (tåg): (1280000 5000)
TF-IDF form (test): (320000 5000)

Steg 7: Träna Bernoulli Naive Bayes modell

• Här tränar vi en Bernoulli Naive Bayes klassificerare på TF IDF-funktionerna från träningsdata.
• Den förutsäger känslor för testdata och skriver sedan ut exaktheten och en detaljerad 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:

Steg 9: Train Support Vector Machine (SVM) modell

• Denna kod tränar en Support Vector Machine (SVM) med maximalt 1000 iterationer på TF IDF-funktionerna.
• Den förutsäger testetiketter och skriver sedan ut noggrannheten och en detaljerad klassificeringsrapport som visar hur väl SVM presterade.

   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:

Steg 10: Träna logistisk regressionsmodell

• Denna kod tränar en Logistisk regression modell med upp till 100 iterationer på TF IDF-funktionerna.
• Den förutsäger sentimentetiketter för testdata och skriver ut noggrannheten och den detaljerade klassificeringsrapporten för modellutvärdering.

   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:

Steg 11: Gör förutsägelser på exempel på tweets

• Den här koden tar tre exempel på tweets och omvandlar dem till TF IDF-funktioner med samma vektoriserare.
• Den förutsäger sedan deras känslor med hjälp av de tränade BernoulliNB SVM- och Logistic Regression-modellerna och skriver ut resultaten för varje klassificerare.
• Där 1 står för positiv och 0 för 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 att våra modeller fungerar bra och ger samma förutsägelser även med olika tillvägagångssätt.

Du kan ladda ner källkoden härifrån- Twitter Sentiment Analysis med Python