L'analisi del sentiment di Twitter è il processo che utilizza Python per comprendere automaticamente le emozioni o le opinioni espresse nei tweet. Analizzando il testo possiamo classificare i tweet come positivi negativi o neutri. Ciò aiuta le aziende e i ricercatori a monitorare la reputazione del marchio sull’umore del pubblico o le reazioni agli eventi in tempo reale. Le librerie Python come TextBlob Tweepy e NLTK semplificano la raccolta dei tweet, l'elaborazione del testo e l'esecuzione efficiente dell'analisi del sentiment.

In che modo è utile l'analisi del sentiment di Twitter?

• L’analisi del sentiment di Twitter è importante perché aiuta le persone e le aziende a capire cosa pensa il pubblico in tempo reale.
• Ogni giorno vengono pubblicati milioni di tweet che condividono opinioni su marchi, prodotti, eventi o questioni sociali. Analizzando questo enorme flusso di dati, le aziende possono misurare tempestivamente le tendenze della soddisfazione dei clienti, gestire rapidamente i feedback negativi e prendere decisioni migliori in base a come si sentono effettivamente le persone.
• È utile anche per ricercatori e governi monitorare l’umore del pubblico durante le crisi elettorali o i grandi eventi poiché trasforma i tweet grezzi in informazioni preziose.

Implementazione passo dopo passo

Passaggio 1: installare le librerie necessarie

Questo blocco installa e importa le librerie richieste. Utilizza panda per caricare e gestire i dati TfidfVectorizer per trasformare il testo in numeri e scikit impara per addestrare il modello.

   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   

Passaggio 2: caricare il set di dati

• Qui carichiamo il file Set di dati Sentiment140 da un file CSV compresso puoi scaricarlo da Kaggle.
• Manteniamo solo la polarità e le colonne di testo del tweet le rinominiamo per chiarezza e stampiamo le prime righe per controllare i dati.

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

Produzione:

Passaggio 3: mantieni solo sentimenti positivi e negativi

• Qui rimuoviamo i tweet neutri in cui la polarità è 2 mappamo le etichette in modo che 0 rimanga negativo e 4 diventi 1 per positivo.
• Quindi stampiamo quanti tweet positivi e negativi sono rimasti nei dati.

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

Produzione:

Passaggio 4: pulisci i tweet

• Qui definiamo una semplice funzione per convertire tutto il testo in minuscolo per coerenza applicandola a ogni tweet nel set di dati.
• Quindi mostra le versioni originali e pulite dei primi tweet.

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

Produzione:

Passaggio 5: suddivisione del test del treno

• Questo codice divide le colonne clean_text e polarity in set di training e test utilizzando una suddivisione 80/20.
• random_state=42 garantisce la riproducibilità.

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

Produzione:

Dimensione del treno: 1280000
Dimensione del test: 320000

Passaggio 6: eseguire la vettorizzazione

• Questo codice crea un vettorizzatore TF IDF che converte il testo in caratteristiche numeriche utilizzando unigrammi e bigrammi limitati a 5000 caratteristiche.
• Adatta e trasforma i dati di addestramento e trasforma i dati di test, quindi stampa le forme delle matrici TF IDF risultanti.

   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  )   

Produzione:

Forma TF-IDF (treno): (1280000 5000)
Forma TF-IDF (test): (320000 5000)

Passo 7: Addestra il modello Bernoulli Naive Bayes

• Qui alleniamo a Bernoulli Naive Bayes classificatore sulle funzionalità TF IDF dai dati di addestramento.
• Prevede le opinioni sui dati del test e quindi stampa l'accuratezza e un rapporto di classificazione dettagliato.

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

Produzione:

Passaggio 9: modello Train Support Vector Machine (SVM).

• Questo codice addestra a Supporto macchina vettoriale (SVM) con un massimo di 1000 iterazioni sulle funzionalità TF IDF.
• Prevede le etichette di prova, quindi stampa la precisione e un rapporto di classificazione dettagliato che mostra le prestazioni dell'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  ))   

Produzione:

Passaggio 10: modello di regressione logistica del treno

• Questo codice addestra a Regressione logistica modello con un massimo di 100 iterazioni sulle funzionalità TF IDF.
• Prevede le etichette di sentiment per i dati di test e stampa l'accuratezza e il rapporto di classificazione dettagliato per la valutazione del modello.

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

Produzione:

Passaggio 11: fai previsioni sui tweet di esempio

• Questo codice prende tre tweet di esempio e li trasforma in funzionalità TF IDF utilizzando lo stesso vettorizzatore.
• Quindi prevede il loro sentiment utilizzando i modelli BernoulliNB SVM e Regressione Logistica addestrati e stampa i risultati per ciascun classificatore.
• Dove 1 sta per Positivo e 0 per Negativo.

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

Produzione:

Possiamo vedere che i nostri modelli funzionano bene e forniscono le stesse previsioni anche con approcci diversi.

Puoi scaricare il codice sorgente da qui- Analisi del sentiment di Twitter utilizzando Python