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=(12)) 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('nBernoulliNB 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('nSVM Classification Report:n' classification_report(y_test svm_pred)) 

Saída:

como encontro aplicativos ocultos no Android

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('nLogistic 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('nSample 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