L'anàlisi de sentiments de Twitter és el procés d'utilitzar Python per comprendre les emocions o opinions expressades en els tuits de manera automàtica. Analitzant el text podem classificar els tuits com a positius negatius o neutres. Això ajuda les empreses i els investigadors a fer un seguiment de la reputació de la marca de l'estat d'ànim públic o les reaccions als esdeveniments en temps real. Les biblioteques de Python com TextBlob Tweepy i NLTK faciliten la recopilació de tuits que processen el text i realitzen anàlisis de sentiments de manera eficient.

Com és útil l'anàlisi de sentiments de Twitter?

• L'anàlisi de sentiments de Twitter és important perquè ajuda les persones i les empreses a entendre què pensa el públic en temps real.
• Cada dia es publiquen milions de tuits compartint opinions sobre esdeveniments de productes de marques o qüestions socials. Mitjançant l'anàlisi d'aquest gran flux de dades, les empreses poden mesurar les tendències locals de satisfacció del client, gestionar ràpidament els comentaris negatius i prendre millors decisions en funció de com se sent realment la gent.
• També és útil per als investigadors i els governs controlar l'estat d'ànim del públic durant les crisis electorals o els grans esdeveniments, ja que converteix els tuits en brut en informació valuosa.

Implementació pas a pas

Pas 1: instal·leu les biblioteques necessàries

Aquest bloc instal·la i importa les biblioteques necessàries. S'utilitza pandes per carregar i gestionar dades TfidfVectoritzador convertir el text en números i scikit aprendre model d'entrenament.

   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   

Pas 2: Carregueu el conjunt de dades

• Aquí carreguem el Conjunt de dades Sentiment140 des d'un fitxer CSV comprimit el podeu descarregar des de Kaggle.
• Mantenim només la polaritat i les columnes de text del tweet les canvien de nom per a més claredat i imprimeixen les primeres files per comprovar les dades.

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

Sortida:

Pas 3: Mantingueu només els sentiments positius i negatius

• Aquí eliminem els tuits neutres on la polaritat és 2, mapeja les etiquetes de manera que 0 es manté negatiu i 4 es converteix en 1 per a positiu.
• A continuació, imprimim quants tuits positius i negatius queden a les dades.

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

Sortida:

Pas 4: netegeu els tuits

• Aquí definim una funció senzilla per convertir tot el text en minúscules per a la coherència que l'apliqui a cada tuit del conjunt de dades.
• A continuació, mostra les versions originals i netes dels primers tuits.

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

Sortida:

Pas 5: Divisió de prova del tren

• Aquest codi divideix les columnes clean_text i polaritat en conjunts d'entrenament i proves mitjançant una divisió 80/20.
• random_state=42 garanteix la reproductibilitat.

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

Sortida:

Mida del tren: 1280000
Mida de la prova: 320000

Pas 6: Realitzeu la vectorització

• Aquest codi crea un vectoritzador TF IDF que converteix el text en característiques numèriques utilitzant unigrames i bigrames limitats a 5000 característiques.
• S'adapta i transforma les dades d'entrenament i transforma les dades de prova i després imprimeix les formes de les matrius TF IDF resultants.

   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  )   

Sortida:

Forma TF-IDF (tren): (1280000 5000)
Forma TF-IDF (prova): (320000 5000)

Pas 7: Entrenar el model de Bernoulli Naive Bayes

• Aquí entrenem a Bernoulli Naive Bayes classificador de les característiques TF IDF a partir de les dades d'entrenament.
• Preveu els sentiments de les dades de prova i després imprimeix la precisió i un informe de classificació detallat.

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

Sortida:

Pas 9: model de màquina vectorial de suport al tren (SVM).

• Aquest codi entrena a Màquina vectorial de suport (SVM) amb un màxim de 1000 iteracions de les funcions de TF IDF.
• Preveu les etiquetes de prova i després imprimeix la precisió i un informe de classificació detallat que mostra el bon rendiment de l'SVM.

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

Sortida:

Pas 10: Model de regressió logística d'entrenament

• Aquest codi entrena a Regressió logística model amb fins a 100 iteracions de les funcions TF IDF.
• Preveu les etiquetes de sentiment per a les dades de prova i imprimeix l'informe de classificació detallat i de precisió per a l'avaluació del model.

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

Sortida:

Pas 11: feu prediccions sobre els tuits de mostra

• Aquest codi pren tres tuits de mostra i els transforma en funcions TF IDF utilitzant el mateix vectoritzador.
• A continuació, prediu el seu sentiment utilitzant els models entrenats BernoulliNB SVM i Logistic Regression i imprimeix els resultats per a cada classificador.
• On 1 significa positiu i 0 significa negatiu.

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

Sortida:

Podem veure que els nostres models funcionen bé i donen les mateixes prediccions fins i tot amb diferents enfocaments.

Podeu descarregar el codi font des d'aquí- Anàlisi de sentiments de Twitter amb Python