Twitter Sentiment Analysis in Python – Multinomial Naive Bayes

Twitter Sentiment Analysis: Understanding Public Opinion

The project aims to develop a sentiment analysis system that analyzes tweets from Twitter and classifies them into positive, negative, or neutral sentiment categories. The system will provide insights into public opinion on various topics, such as products, events, or social issues, by analyzing the sentiment expressed in tweets.

Project Goals and Objectives:

  1. Collecting Twitter data: Develop a program to retrieve and collect tweets related to a specific topic or hashtag from the Twitter API.
  2. Data preprocessing: Clean the collected data by removing noise, such as hashtags, URLs, and special characters, and perform tokenization, stemming, and stop-word removal to prepare the text for analysis.
  3. Sentiment analysis algorithms: Implement and compare different sentiment analysis algorithms, such as Naive Bayes, Support Vector Machines, or Recurrent Neural Networks, to classify tweets into positive, negative, or neutral sentiment categories.
  4. Building a sentiment analysis model: Train a sentiment analysis model using a labeled dataset for sentiment classification and evaluate its performance using appropriate metrics like accuracy, precision, recall, and F1-score.
  5. Real-time sentiment analysis: Develop a system that continuously streams and analyzes tweets in real time, providing immediate sentiment insights on the analyzed topic.
  6. Visualization and reporting: Visualize the sentiment analysis results using charts, graphs, or word clouds to present the overall sentiment distribution and provide a comprehensive report summarizing the findings.

Optional Enhancements:

  1. Emotion analysis: Extend the sentiment analysis to include emotion detection, identifying emotions like joy, anger, sadness, or surprise expressed in tweets.
  2. Trend analysis: Analyze sentiment trends over time to identify shifts in public opinion and track the sentiment of a topic over a specific period.
  3. User sentiment analysis: Analyze the sentiment of specific Twitter users or influential accounts to understand their impact on public opinion.
  4. Geolocation-based analysis: Incorporate geolocation data to analyze sentiment variations across regions or countries.

Required Tools and Technologies and GitHub code:

  • Programming language: Python
  • Twitter API for data collection
  • Natural Language Processing (NLP) libraries like NLTK or SpaCy
  • Machine learning or deep learning frameworks like sci-kit-learn or TensorFlow
  • Data visualization libraries like Matplotlib or Seaborn

Note: It is essential to consider the ethical aspects of collecting and analyzing Twitter data, including user privacy, terms of service compliance, and responsible data handling. You can find this code on GitHub also.

This project offers an opportunity to gain practical experience in text mining, sentiment analysis, and working with real-time data from social media platforms. It can contribute to understanding public opinion, brand monitoring, market research, and social media analytics.

Step 1: Collecting Twitter Data

To collect tweets related to a specific topic or hashtag, you’ll need to use the Twitter API. Here’s an example code snippet using the Tweepy library to retrieve tweets:

import tweepy

# API credentials
consumer_key = 'YOUR_CONSUMER_KEY'
consumer_secret = 'YOUR_CONSUMER_SECRET'
access_token = 'YOUR_ACCESS_TOKEN'
access_token_secret = 'YOUR_ACCESS_TOKEN_SECRET'

# Authenticate with Twitter API
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)

# Create API object
api = tweepy.API(auth)

# Retrieve tweets
keyword = 'your_topic_or_hashtag'
tweets = tweepy.Cursor(, q=keyword, tweet_mode='extended').items(1000)

# Print retrieved tweets
for tweet in tweets:

Make sure to replace 'YOUR_CONSUMER_KEY', 'YOUR_CONSUMER_SECRET', 'YOUR_ACCESS_TOKEN', and 'YOUR_ACCESS_TOKEN_SECRET' with your actual Twitter API credentials.

Step 2: Data Preprocessing

In this step, you’ll clean the collected tweet data by removing noise and performing text preprocessing tasks. Here’s an example code snippet using the NLTK library for data preprocessing:

import re
import nltk
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer'stopwords')

# Text preprocessing function
def preprocess_text(text):
    # Remove URLs
    text = re.sub(r'http\S+', '', text)

    # Remove special characters and numbers
    text = re.sub(r'[^a-zA-Z]', ' ', text)

    # Convert to lowercase
    text = text.lower()

    # Tokenization
    tokens = text.split()

    # Remove stopwords and perform stemming
    stop_words = set(stopwords.words('english'))
    stemmer = PorterStemmer()
    tokens = [stemmer.stem(word) for word in tokens if word not in stop_words]

    # Join the tokens back into a single string
    preprocessed_text = ' '.join(tokens)

    return preprocessed_text

# Preprocess the tweet text
preprocessed_tweets = [preprocess_text(tweet.full_text) for tweet in tweets]

Step 3: Sentiment Analysis Algorithms

Implementing different sentiment analysis algorithms allows you to compare their performance. Here’s an example code snippet using the sci-kit-learn Naive Bayes classifier for sentiment analysis:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Prepare the dataset (you'll need labeled data for training)
X = preprocessed_tweets  # Preprocessed tweet text
y = labels  # Labeled sentiment (positive, negative, neutral)

# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Vectorize the text using TF-IDF
vectorizer = TfidfVectorizer()
X_train = vectorizer.fit_transform(X_train)
X_test = vectorizer.transform(X_test)

# Train the sentiment analysis model (Naive Bayes classifier)
classifier = MultinomialNB(), y_train)

# Predict sentiment for test set
y_pred = classifier.predict(X_test)

# Evaluate the model
print(classification_report(y_test, y_pred))

Step 4: Real-Time Sentiment Analysis

To perform sentiment analysis on real-time tweets, you’ll need to use the streaming API provided by Tweepy. Here’s an example code snippet:

from tweepy.streaming import StreamListener
from tweepy import Stream

# Define a custom StreamListener
class CustomStreamListener(StreamListener):
    def on_status(self, status):
        # Preprocess the tweet text
        preprocessed_text = preprocess_text(status.full_text)

        # Vectorize the preprocessed text
        vectorized_text = vectorizer.transform([preprocessed_text])

        # Predict the sentiment
        sentiment = classifier.predict(vectorized_text)[0]

        # Print the sentiment and the tweet
        print('Sentiment:', sentiment)
        print('Tweet:', status.full_text)

# Create a StreamListener object
stream_listener = CustomStreamListener()

# Create a Stream object with authentication
stream = Stream(auth=api.auth, listener=stream_listener)

# Start streaming tweets with the specified keyword(s)

The code above will stream and analyze real-time tweets based on the specified topic or hashtag, printing the predicted sentiment for each tweet.

Please note that these code snippets provide a basic implementation for each project step. You may need to adapt and extend them based on your specific requirements and data availability. Additionally, you’ll need to consider data labeling for training the sentiment analysis model and handling rate limits and Twitter API restrictions.

Here’s an example code design for performing sentiment analysis on static data, such as a CSV file containing tweet data:

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB

# Load the CSV file
data = pd.read_csv('tweet_data.csv')

# Preprocess the tweet text
data['PreprocessedText'] = data['Text'].apply(preprocess_text)

# Vectorize the text using TF-IDF
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(data['PreprocessedText'])

# Prepare the labels
y = data['Sentiment']

# Train the sentiment analysis model (Naive Bayes classifier)
classifier = MultinomialNB(), y)

# Predict sentiment for all tweets
y_pred = classifier.predict(X)

# Add predicted sentiment to the dataframe
data['PredictedSentiment'] = y_pred

# Generate a histogram of sentiment distribution
sentiment_counts = data['PredictedSentiment'].value_counts()
sentiment_counts.plot(kind='bar', color=['green', 'red', 'blue'])
plt.title('Sentiment Distribution of Tweets')


In this code, after predicting the sentiment for each tweet, the code adds the predicted sentiment as a new column to the data frame. Then, it generates a histogram using the value_counts() function to count the occurrences of each sentiment category and plot a bar chart. The resulting histogram visualizes the sentiment distribution of the tweets.

Make sure to replace 'tweet_data.csv' with the path and filename of your actual CSV file. Also, ensure that you import the necessary libraries before running the code.

Please note that the colors used in the histogram are set to green, red, and blue for positive, negative, and neutral sentiments, respectively. Feel free to modify the color scheme according to your preference.

Twitter Sentiment Analysis: How To

In the era of social media dominance, Twitter has emerged as a powerful platform for expressing opinions and sentiments. Understanding the collective sentiment of Twitter users has become crucial for businesses, researchers, and decision-makers alike. This article aims to provide a comprehensive guide to performing Twitter sentiment analysis, a data science technique that enables us to extract valuable insights from the vast sea of tweets. We will delve into the theoretical foundations, practical implementation, and optimization strategies for conducting sentiment analysis on Twitter data, allowing you to unlock the power of sentiment analysis and learn data science techniques in the process.

  1. Theoretical Foundations of Twitter Sentiment Analysis:

1.1 Understanding Sentiment Analysis:

  • Definition of sentiment analysis and its applications.
  • Importance of sentiment analysis in the age of social media.
  • Challenges and considerations in sentiment analysis.

1.2 Sentiment Analysis Techniques:

  • Overview of rule-based, machine learning, and deep learning approaches.
  • Focus on machine learning algorithms such as Naive Bayes, SVM, and neural networks for sentiment analysis.
  • Advantages and limitations of different techniques.
  1. Twitter Data Collection: 2.1 Accessing the Twitter API:
    • Introduction to the Twitter API and its capabilities.
    • Setting up API credentials for data retrieval.
    • Collecting tweets using the Streaming API and Search API.

2.2 Preprocessing Twitter Data:

  • Cleaning and filtering tweet data to remove noise.
  • Handling special characters, URLs, and hashtags.
  • Tokenization, stemming, and stop-word removal.
  1. Sentiment Analysis Implementation: 3.1 Building a Labeled Dataset:
    • Approaches to label tweets for training and evaluation.
    • Manual labeling, crowdsourcing, and existing sentiment lexicons.

3.2 Feature Extraction:

  • Representing tweet text using bag-of-words or TF-IDF features.
  • Embedding techniques like Word2Vec or GloVe for semantic representation.

3.3 Training and Evaluating Sentiment Analysis Models:

  • Splitting the dataset into training and testing sets.
  • Training various machine learning models like Naive Bayes, SVM, and neural networks.
  • Evaluation metrics for assessing model performance.
  1. Real-Time Twitter Sentiment Analysis:
    • Implementing sentiment analysis on real-time streaming tweets using the Twitter API.
    • Techniques for continuously analyzing and visualizing sentiments as they unfold.
    • Challenges and considerations in real-time sentiment analysis.
  2. Optimization Strategies for Twitter Sentiment Analysis: 5.1 Handling Imbalanced Datasets:
    • Techniques for addressing the class imbalance in sentiment analysis datasets.
    • Oversampling, undersampling, and hybrid approaches.

5.2 Model Fine-Tuning and Hyperparameter Optimization:

  • Fine-tuning machine learning models to achieve better performance.
  • Grid search, random search, and Bayesian optimization for hyperparameter tuning.

5.3 Enhancing Performance with Ensemble Methods:

  • Leveraging ensemble techniques such as bagging and boosting for improved sentiment analysis results.
  • Combining the predictions of multiple models to achieve better accuracy.
  1. Conclusion: In conclusion, Twitter sentiment analysis serves as a powerful tool for gauging public opinion and sentiment on a vast scale. By harnessing the potential of data science and machine learning techniques, we can extract valuable insights from the Twitterverse and make informed decisions. This article has provided a comprehensive guide to performing sentiment analysis on Twitter data, offering theoretical foundations, practical implementation steps, and optimization strategies. Through the process of exploring Twitter sentiment analysis, you have also gained valuable knowledge in the field of data science. So, dive into the realm of sentiment analysis, learn data science techniques, and unlock the immense potential of understanding sentiments in real time on Twitter.

4 thoughts on “Twitter Sentiment Analysis in Python – Multinomial Naive Bayes”

  1. Your content never disappoints, and I’m grateful for the valuable insight you share. For AI and automation knowledge, James Jernigan’s YouTube channel is my top choice. His brilliant tips have made a significant difference in my business, enabling me to automate processes and earn more online.


Leave a Comment