Análise de sentimento do Twitter é o processo de usar Python para compreender automaticamente as emoções ou opiniões expressas em tweets. Ao analisar o texto podemos classificar os tweets como positivos, negativos ou neutros. Isso ajuda empresas e pesquisadores a rastrear a reputação da marca ou as reações do público a eventos em tempo real. Bibliotecas Python como TextBlob Tweepy e NLTK facilitam a coleta de tweets, processam o texto e realizam análises de sentimento com eficiência.

Como a análise de sentimento do Twitter é útil?

• A análise de sentimento do Twitter é importante porque ajuda pessoas e empresas a entender o que o público pensa em tempo real.
• Milhões de tweets são postados todos os dias compartilhando opiniões sobre eventos de produtos de marcas ou questões sociais. Ao analisar esse enorme fluxo de dados, as empresas podem medir a satisfação do cliente, detectar tendências antecipadamente, lidar com feedback negativo rapidamente e tomar decisões melhores com base em como as pessoas realmente se sentem.
• Também é útil para investigadores e governos monitorizarem o humor do público durante crises eleitorais ou grandes eventos, pois transforma tweets brutos em informações valiosas.

Implementação passo a passo

Etapa 1: instale as bibliotecas necessárias

Este bloco instala e importa as bibliotecas necessárias. Ele usa pandas para carregar e manipular dados Vetorizador Tfidf para transformar texto em números e aprender para treinar modelo.

   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   

Etapa 2: carregar conjunto de dados

• Aqui carregamos o Conjunto de dados Sentiment140 de um arquivo CSV compactado, você pode baixá-lo do Kaggle.
• Mantemos apenas a polaridade e as colunas de texto do tweet as renomeamos para maior clareza e imprimimos as primeiras linhas para verificar os dados.

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

Saída:

Etapa 3: mantenha apenas sentimentos positivos e negativos

• Aqui removemos tweets neutros onde a polaridade é 2 mapeia os rótulos para que 0 permaneça negativo e 4 se torne 1 para positivo.
• Em seguida, imprimimos quantos tweets positivos e negativos restam nos dados.

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

Saída:

Etapa 4: limpe os tweets

• Aqui definimos uma função simples para converter todo o texto em letras minúsculas para obter consistência e aplicá-la a cada tweet no conjunto de dados.
• Em seguida, mostra as versões originais e limpas dos primeiros tweets.

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

Saída:

Etapa 5: divisão de teste de trem

• Este código divide as colunas clean_text e polarity em conjuntos de treinamento e teste usando uma divisão 80/20.
• random_state=42 garante a reprodutibilidade.

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

Saída:

Tamanho do trem: 1280000
Tamanho do teste: 320.000

Etapa 6: realizar a vetorização

• Este código cria um vetorizador TF IDF que converte texto em recursos numéricos usando unigramas e bigramas limitados a 5.000 recursos.
• Ele ajusta e transforma os dados de treinamento e transforma os dados de teste e, em seguida, imprime as formas das matrizes TF IDF resultantes.

   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  )   

Saída:

Formato TF-IDF (trem): (1280000 5000)
Formato TF-IDF (teste): (320000 5000)

Etapa 7: treinar o modelo Bernoulli Naive Bayes

• Aqui treinamos um Bernoulli Naive Bayes classificador nos recursos TF IDF dos dados de treinamento.
• Ele prevê os sentimentos dos dados de teste e, em seguida, imprime a precisão e um relatório de classificação detalhado.

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

Saída:

Etapa 9: modelo de máquina de vetor de suporte de trem (SVM)

• Este código treina um Máquina de vetores de suporte (SVM) com um máximo de 1000 iterações nos recursos do TF IDF.
• Ele prevê rótulos de teste e depois imprime a precisão e um relatório de classificação detalhado mostrando o desempenho do 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  ))   

Saída:

Etapa 10: treinar modelo de regressão logística

• Este código treina um Regressão Logística modelo com até 100 iterações nos recursos do TF IDF.
• Ele prevê rótulos de sentimento para os dados de teste e imprime a precisão e o relatório de classificação detalhado para avaliação do modelo.

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

Saída:

Etapa 11: faça previsões em exemplos de tweets

• Este código pega três exemplos de tweets e os transforma em recursos TF IDF usando o mesmo vetorizador.
• Em seguida, ele prevê seu sentimento usando os modelos treinados BernoulliNB SVM e regressão logística e imprime os resultados para cada classificador.
• Onde 1 significa Positivo e 0 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  ))   

Saída:

Podemos ver que nossos modelos estão funcionando bem e fornecendo as mesmas previsões, mesmo com abordagens diferentes.

Você pode baixar o código-fonte aqui- Análise de sentimento do Twitter usando Python