Word Cloud of Negative Sentiment Summaries

Exploratory Data Analysis Using Word Cloud for Negative Sentiment Visualization

Exploratory Data Analysis (EDA) is one of the most important stages in every data science and machine learning project. Before building predictive models, analysts must first understand the structure, quality, and characteristics of the dataset. In Natural Language Processing (NLP), EDA becomes even more important because text data is unstructured and difficult to interpret directly.

One powerful visualization technique used in sentiment analysis is the Word Cloud. A word cloud provides a visual representation of the most frequent words appearing in a dataset. The size of each word indicates its frequency or importance in the text corpus.

In this tutorial, we focus specifically on negative sentiment text data where the polarity score is less than zero. The goal is to isolate negative summaries and generate a word cloud that visually highlights the words commonly associated with negative opinions.

Key Learning Objective:
By the end of this tutorial, you will understand how to preprocess text data, filter negative sentiment records, clean text using regular expressions, generate word clouds, and interpret NLP visualizations effectively.

Table of Contents

• Introduction to Exploratory Data Analysis
• Understanding Sentiment Analysis
• What is a Word Cloud?
• Required Python Libraries
• Loading the Dataset
• Understanding Stopwords
• Filtering Negative Sentiment
• Text Cleaning Using Regular Expressions
• Generating the Word Cloud
• Visualizing the Output
• Mathematics Behind Word Frequency
• Key Observations
• Advantages of Word Clouds
• Limitations of Word Clouds
• Complete Python Code
• Related Articles

Introduction to Exploratory Data Analysis

Exploratory Data Analysis (EDA) refers to the process of examining datasets to summarize their key characteristics. EDA uses visualizations, statistical summaries, and preprocessing techniques to understand patterns, trends, anomalies, and relationships within the data.

In NLP projects, EDA helps answer questions like:

• Which words appear most frequently?
• What are the dominant themes in the dataset?
• Are there repeated expressions or phrases?
• What sentiment patterns exist?
• How balanced is the dataset?

Without proper EDA, building machine learning models becomes risky because hidden biases or data quality problems may remain undetected.

Understanding Sentiment Analysis

Sentiment Analysis is a Natural Language Processing technique used to determine whether text expresses:

• Positive sentiment
• Negative sentiment
• Neutral sentiment

A sentiment polarity score is often assigned numerically:

Polarity Score	Meaning
Greater than 0	Positive sentiment
Equal to 0	Neutral sentiment
Less than 0	Negative sentiment

Sentiment Polarity Formula

A simplified sentiment polarity calculation can be represented as:

$$ Polarity = \frac{Positive\ Words - Negative\ Words}{Total\ Words} $$

Where:

• Positive Words = count of positive expressions
• Negative Words = count of negative expressions
• Total Words = total number of words in the sentence

If the result is negative, the sentence is classified as negative sentiment.

What is a Word Cloud?

A Word Cloud is a visual representation of text data where word size corresponds to frequency. Words appearing more often in the dataset are displayed in larger fonts.

Word clouds are commonly used in:

• Sentiment analysis
• Customer review analysis
• Social media analytics
• Product feedback analysis
• Topic modeling
• Exploratory text analysis

Important:
Word clouds are useful for quick visual exploration but should not replace deeper statistical NLP analysis.

Required Python Libraries

The first step involves importing the necessary Python libraries.

from mlAASentimentAnalysis import data
import matplotlib.pyplot as plt
from wordcloud import WordCloud, STOPWORDS

Explanation of Each Library

Library	Purpose
matplotlib.pyplot	Used for plotting graphs and visualizations
WordCloud	Generates word cloud images
STOPWORDS	Provides common words to exclude
mlAASentimentAnalysis	Contains the dataset used for analysis

Loading the Dataset

The dataset contains summaries along with polarity values indicating sentiment orientation.

Example dataset structure:

Summary	Polarity
The product quality was terrible	-0.8
Excellent customer service	0.9
The delivery was delayed badly	-0.6

Each row represents one textual summary and its corresponding sentiment polarity.

Understanding Stopwords

Stopwords are common words that usually do not carry important semantic meaning.

Examples:

• the
• and
• is
• of
• a

stopwords = set(STOPWORDS)

The STOPWORDS list is converted into a set for faster lookup performance.

Set Lookup Time Complexity

Searching inside a Python set is approximately:

$$ O(1) $$

This means lookup operations occur in constant time, making stopword filtering efficient.

Filtering Negative Sentiment

The next step isolates only negative sentiment records.

data_negative = data[data['polarity'] < 0]

This condition selects all rows where:

$$ polarity < 0 $$

The filtered dataset is stored in data_negative.

Why Filter Negative Sentiment Separately?

Negative reviews often reveal valuable customer pain points such as:

• Product defects
• Delivery issues
• Poor customer support
• Pricing complaints
• Service dissatisfaction

Analyzing negative text separately helps organizations improve products and services.

Concatenating Negative Summaries

total_negative = (' '.join(data_negative['Summary']))

The summaries are merged into a single long string because the WordCloud generator processes text as one continuous corpus.

Example:

"The product was bad"
"The support was terrible"

Becomes:

"The product was bad The support was terrible"

Text Cleaning Using Regular Expressions

Raw text often contains:

• Numbers
• Punctuation
• Special symbols
• Extra spaces

These unnecessary elements must be removed before generating the word cloud.

import re

total_negative = re.sub('[^a-zA-Z]', ' ', total_negative)
total_negative = re.sub(' +', ' ', total_negative)

Explanation

Regex Pattern	Meaning
[^a-zA-Z]	Remove non-alphabetical characters
' +'	Replace multiple spaces with one space

Text Cleaning Reduction Formula

Suppose:

• Total characters before cleaning = \(C_b\)
• Total characters removed = \(C_r\)

Then cleaned text length becomes:

$$ C_{clean} = C_b - C_r $$

Reducing noise improves NLP quality and visualization clarity.

Generating the Word Cloud

wordcloud = WordCloud(
    width=1000,
    height=500,
    stopwords=stopwords
).generate(total_negative)

Parameter Explanation

Parameter	Purpose
width	Defines image width
height	Defines image height
stopwords	Removes common irrelevant words
generate()	Builds the word cloud from text

Visualizing the Word Cloud

plt.figure(figsize=(15, 5))
plt.imshow(wordcloud)
plt.axis('off')
plt.show()

Visualization Explanation

• figure() defines plot size
• imshow() displays the word cloud image
• axis('off') removes axes
• show() renders the final visualization

Visualization Goal:
The largest words in the word cloud represent the most frequent negative terms appearing in the dataset.

Mathematics Behind Word Frequency

Word clouds depend heavily on frequency analysis.

Word Frequency Formula

The frequency of a word is:

$$ Frequency(word) = \frac{Count(word)}{Total\ Words} $$

Example:

• Total words = 10,000
• "bad" appears 500 times

$$ Frequency(bad) = \frac{500}{10000} $$ $$ Frequency(bad) = 0.05 $$

This means the word appears in 5% of the dataset.

TF-IDF Concept

Advanced NLP systems use TF-IDF weighting:

$$ TFIDF = TF \times IDF $$

Where:

• TF = Term Frequency
• IDF = Inverse Document Frequency

TF-IDF reduces the importance of overly common words.

Key Observations from the Word Cloud

After generating the visualization, analysts can identify:

• Frequently repeated complaint terms
• Negative customer experiences
• Service-related issues
• Product quality concerns
• Repeated dissatisfaction themes

For example, words like:

• bad
• poor
• terrible
• slow
• broken

may dominate the visualization.

Advantages of Word Clouds

• Easy to interpret visually
• Quick exploratory insights
• Highlights dominant themes
• Useful for presentations
• Good starting point for NLP projects

Limitations of Word Clouds

• Ignores grammar and context
• Does not show semantic relationships
• Cannot detect sarcasm
• May oversimplify analysis
• Frequency alone may be misleading

Best Practice:
Use word clouds together with deeper NLP methods such as TF-IDF, topic modeling, sentiment scoring, and embeddings.

Complete Python Code

from mlAASentimentAnalysis import data
import matplotlib.pyplot as plt
from wordcloud import WordCloud, STOPWORDS
import re

# Stopwords
stopwords = set(STOPWORDS)

# Filter negative sentiment
data_negative = data[data['polarity'] < 0]

# Combine summaries
total_negative = (' '.join(data_negative['Summary']))

# Clean text
total_negative = re.sub('[^a-zA-Z]', ' ', total_negative)
total_negative = re.sub(' +', ' ', total_negative)

# Generate word cloud
wordcloud = WordCloud(
    width=1000,
    height=500,
    stopwords=stopwords
).generate(total_negative)

# Plot word cloud
plt.figure(figsize=(15, 5))
plt.imshow(wordcloud)
plt.axis('off')
plt.show()

Final Thoughts

Word clouds provide an excellent introduction to text visualization in NLP and exploratory data analysis. By isolating negative sentiment records and visualizing their most common words, analysts can quickly identify recurring complaints, emotional patterns, and major customer concerns.

Although word clouds are simple visual tools, they can provide surprisingly valuable insights during the early stages of data analysis. Combined with proper preprocessing, stopword filtering, and sentiment scoring, they become powerful aids in understanding textual datasets.

Final Key Insight:
Exploratory Data Analysis is not only about statistics. In NLP, visual tools like WordCloud help transform large collections of unstructured text into understandable patterns that humans can quickly interpret.