L'analyse des sentiments sur Twitter est le processus d'utilisation de Python pour comprendre automatiquement les émotions ou les opinions exprimées dans les tweets. En analysant le texte, nous pouvons classer les tweets comme positifs, négatifs ou neutres. Cela aide les entreprises et les chercheurs à suivre en temps réel l’humeur du public, la réputation de la marque ou les réactions aux événements. Les bibliothèques Python telles que TextBlob Tweepy et NLTK facilitent la collecte de tweets, traitent le texte et effectuent efficacement une analyse des sentiments.

En quoi l’analyse des sentiments sur Twitter est-elle utile ?

• L'analyse des sentiments sur Twitter est importante car elle aide les particuliers et les entreprises à comprendre ce que pense le public en temps réel.
• Des millions de tweets sont publiés chaque jour pour partager des opinions sur les produits des marques, des événements ou des problèmes sociaux. En analysant cet énorme flux de données, les entreprises peuvent mesurer rapidement les tendances de satisfaction des clients, gérer rapidement les commentaires négatifs et prendre de meilleures décisions en fonction de ce que ressentent réellement les gens.
• Il est également utile aux chercheurs et aux gouvernements pour surveiller l’humeur du public lors de crises électorales ou de grands événements, car il transforme les tweets bruts en informations précieuses.

Mise en œuvre étape par étape

Étape 1 : Installer les bibliothèques nécessaires

Ce bloc installe et importe les bibliothèques requises. Il utilise pandas charger et gérer des données TfidfVectorizer transformer du texte en chiffres et scikit apprendre pour entraîner le modèle.

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 

Étape 2 : Charger l'ensemble de données

• Ici, nous chargeons le Ensemble de données Sentiment140 à partir d'un fichier CSV compressé, vous pouvez le télécharger depuis Kaggle.
• Nous conservons uniquement les colonnes de polarité et de texte du tweet, les renomme pour plus de clarté et imprimons les premières lignes pour vérifier les données.

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

Sortir:

Étape 3 : Ne conservez que les sentiments positifs et négatifs

• Ici, nous supprimons les tweets neutres où la polarité est de 2 et mappons les étiquettes afin que 0 reste négatif et 4 devienne 1 pour positif.
• Ensuite, nous imprimons combien de tweets positifs et négatifs restent dans les données.

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

Sortir:

Étape 4 : nettoyer les tweets

• Ici, nous définissons une fonction simple pour convertir tout le texte en minuscules par souci de cohérence et l'appliquons à chaque tweet de l'ensemble de données.
• Affiche ensuite les versions originales et nettoyées des premiers tweets.

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

Sortir:

Étape 5 : Répartition des tests d'entraînement

• Ce code divise les colonnes clean_text et polarity en ensembles d'entraînement et de test en utilisant une répartition 80/20.
• random_state=42 garantit la reproductibilité.

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

Sortir:

Taille du train : 1 280 000
Taille du test : 320 000

Étape 6 : Effectuer la vectorisation

• Ce code crée un vectoriseur TF IDF qui convertit le texte en caractéristiques numériques à l'aide d'unigrammes et de bigrammes limités à 5 000 caractéristiques.
• Il ajuste et transforme les données d'entraînement et transforme les données de test, puis imprime les formes des matrices TF IDF résultantes.

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) 

Sortir:

Forme TF-IDF (train) : (1280000 5000)
Forme TF-IDF (test) : (320000 5000)

Étape 7 : Former le modèle Bernoulli Naive Bayes

• Ici, nous formons un Bernoulli Naive Bayes classificateur sur les fonctionnalités TF IDF à partir des données de formation.
• Il prédit les sentiments pour les données de test, puis imprime la précision et un rapport de classification détaillé.

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

Sortir:

Étape 9 : Former le modèle de machine à vecteurs de support (SVM)

• Ce code forme un Machine à vecteurs de support (SVM) avec un maximum de 1000 itérations sur les fonctionnalités TF IDF.
• Il prédit les étiquettes de test, puis imprime la précision et un rapport de classification détaillé montrant les performances du 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)) 

Sortir:

xor c++

Étape 10 : Former le modèle de régression logistique

• Ce code forme un Régression logistique modèle avec jusqu'à 100 itérations sur les fonctionnalités TF IDF.
• Il prédit les étiquettes de sentiment pour les données de test et imprime le rapport de précision et de classification détaillé pour l'évaluation du modèle.

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

Sortir:

Étape 11 : Faites des prédictions sur des exemples de tweets

• Ce code prend trois exemples de tweets et les transforme en fonctionnalités TF IDF en utilisant le même vectoriseur.
• Il prédit ensuite leur sentiment à l'aide des modèles BernoulliNB SVM et de régression logistique formés et imprime les résultats pour chaque classificateur.
• Où 1 signifie positif et 0 signifie négatif.

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

Sortir:

Nous pouvons voir que nos modèles fonctionnent bien et donnent les mêmes prédictions même avec des approches différentes.

Vous pouvez télécharger le code source à partir d'ici- Analyse des sentiments Twitter à l'aide de Python