MB - Mark Blog
Sentiment AnalysisNLPMachine learning

Application on Sentiment Analysis

Introduction

Natural Language Processing (NLP) is a crucial field in artificial intelligence (AI) that enables machines to understand, process, and generate human language. One of its most practical applications is Sentiment Analysis, which helps businesses and researchers extract insights from customer reviews, social media posts, and textual data.

In this article, we’ll explore the fundamental principles of NLP and Sentiment Analysis, and discuss how these techniques were applied in a study comparing customer reviews of two handheld gaming consoles: Nintendo DS (NDS) and PlayStation Portable (PSP). We’ll also examine the business implications of these technologies and how they can be used in various industries.

1. What is Natural Language Processing (NLP)?

1.1 Definition and Importance

NLP is a field within AI that focuses on enabling computers to understand and interact with human language. It combines computational linguistics, machine learning, and deep learning to analyze textual data. NLP is widely applied in various domains, including:

  • Sentiment Analysis – Extracting emotions and opinions from text.
  • Text Classification – Categorizing documents (e.g., spam detection, news classification).
  • Named Entity Recognition (NER) – Identifying names, organizations, and locations in text.
  • Machine Translation – Converting text between languages (e.g., Google Translate).
  • Speech Recognition – Transcribing spoken words into text (e.g., Siri, Alexa).

1.2 Challenges in NLP

Understanding human language is complex due to:

  • Ambiguity – The same word can have different meanings in different contexts.
  • Syntax and Grammar Variability – Natural language lacks strict rules like programming languages.
  • Context Dependence – Understanding meaning often requires broader context.

2. Core Techniques in NLP

2.1 Text Preprocessing

Before textual data can be analyzed, it needs to be cleaned and structured. Common preprocessing steps include:

  • Tokenization – Splitting text into words or phrases (e.g., “I love gaming” → ["I", "love", "gaming"]).

    import nltk
from nltk.tokenize import word_tokenize

text = "I love gaming"
tokens = word_tokenize(text)
print(tokens)  # Output: ['I', 'love', 'gaming']

  • Stopword Removal – Removing common words that don’t add much meaning (e.g., "is", "the", "and").

    from nltk.corpus import stopwords

stop_words = set(stopwords.words('english'))
filtered_tokens = [word for word in tokens if word.lower() not in stop_words]
print(filtered_tokens)  # Output: ['love', 'gaming']

  • Lemmatization & Stemming – Converting words to their root form (e.g., "running" → "run").

    from nltk.stem import WordNetLemmatizer

lemmatizer = WordNetLemmatizer()
lemmatized_tokens = [lemmatizer.lemmatize(word) for word in filtered_tokens]
print(lemmatized_tokens)  # Output: ['love', 'gaming']

2.2 Feature Extraction and Word Representation

Since machines cannot process raw text directly, NLP converts words into numerical representations:

  • TF-IDF (Term Frequency-Inverse Document Frequency) – Weighs word importance based on frequency.

    from sklearn.feature_extraction.text import TfidfVectorizer

documents = ["I love gaming", "Gaming is fun"]
vectorizer = TfidfVectorizer()
tfidf_matrix = vectorizer.fit_transform(documents)
print(tfidf_matrix.toarray())

    Mathematical formulas explaining TF-IDF calculation:

    TF(w) = (Number of times term w appears in document) / (Total number of terms in document)
IDF(w) = log(N / (1 + DF(w)))

    where N is the total number of documents and DF(w) is the number of documents containing term w.

  • Word2Vec, GloVe – Transforms words into vector embeddings to capture semantic relationships.

    from gensim.models import Word2Vec

sentences = [["I", "love", "gaming"], ["Gaming", "is", "fun"]]
model = Word2Vec(sentences, min_count=1)
print(model.wv['gaming'])  # Output: vector representation of 'gaming'

  • BERT (Bidirectional Encoder Representations from Transformers) – A deep learning model that understands words in context.

    from transformers import BertTokenizer, BertModel
import torch

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')

inputs = tokenizer("I love gaming", return_tensors="pt")
outputs = model(**inputs)
print(outputs.last_hidden_state)  # Output: BERT embeddings

2.3 Machine Learning and Deep Learning Models in NLP

NLP can utilize traditional machine learning or deep learning approaches:

  • Traditional Models:

    • Naïve Bayes – Common for spam filtering and text classification.

    • Support Vector Machines (SVM) – Used for small datasets with high accuracy.

      • Mathematical Explanation: SVM finds the hyperplane that best separates the classes in the feature space. The decision boundary is defined by: 
        w · x + b = 0
        where w is the weight vector, x is the input vector, and b is the bias.

    • Random Forest – An ensemble method for classification tasks.

  • Deep Learning Models:

    • LSTM (Long Short-Term Memory) – Handles long text sequences well.

      • Mathematical Explanation: LSTMs use gates to control the flow of information:
        • Forget gate: decides what information to discard.
        • Input gate: decides what new information to store.
        • Output gate: decides what to output.

    • Transformer Models (BERT, GPT) – Captures context in a sentence, outperforming previous models.

3. What is Sentiment Analysis?

3.1 Definition and Purpose

Sentiment Analysis, or opinion mining, is the process of determining the sentiment expressed in a piece of text. It categorizes sentiment as:

  • Positive – “This console is amazing!”
  • Neutral – “The device works as expected.”
  • Negative – “Battery life is terrible.”

3.2 Approaches to Sentiment Analysis

(1) Lexicon-Based Methods

  • Uses predefined sentiment dictionaries like SentiWordNet to score words.

  • Example code using TextBlob:

    from textblob import TextBlob

text = "This console is amazing!"
blob = TextBlob(text)
print(blob.sentiment)  # Output: Sentiment(polarity=0.8, subjectivity=0.75)

  • Limitations: Cannot handle sarcasm, slang, or context-dependent sentiment effectively.

(2) Machine Learning-Based Methods

  • Trains models on labeled datasets to classify text.

  • Example code using sklearn:

    from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

X = [...]  # Feature vectors
y = [...]  # Labels
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = LogisticRegression()
model.fit(X_train, y_train)
print(model.score(X_test, y_test))  # Output: Accuracy

  • Popular models: Logistic Regression, SVM, Random Forest.

  • Strengths: Learns from examples but requires large labeled datasets.

(3) Deep Learning-Based Methods

  • Uses LSTM, CNN, and BERT to capture complex relationships in text.
  • Example code using transformers (BERT): 
    from transformers import pipeline

sentiment_pipeline = pipeline("sentiment-analysis")
result = sentiment_pipeline("This console is sick!")
print(result)  # Output: [{'label': 'POSITIVE', 'score': 0.99}]

4. Case Study: Sentiment Analysis of PSP vs. NDS

4.1 Research Setup

This study applied Sentiment Analysis to Amazon reviews of two gaming consoles to analyze consumer preferences and market trends.

  • Dataset: 470,000 Amazon reviews from 2000–2018.

  • Text Processing: Tokenization, stopword removal, stemming (NLTK used).

  • Sample data preprocessing and dataset splitting:

    import pandas as pd
from sklearn.model_selection import train_test_split

df = pd.read_csv('amazon_reviews.csv')  # Load dataset
X = df['review_text']
y = df['sentiment']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

  • Modeling Approaches:

    • Defined sentiment labels: Scores ≤ 2 = Negative, 4+ = Positive, 3 = Neutral.
    • Trained Logistic Regression, SVM, and Random Forest to predict sentiment.

  • Visualization of sentiment distribution:

    import matplotlib.pyplot as plt
import seaborn as sns

sns.countplot(x='sentiment', data=df)
plt.title('Sentiment Distribution')
plt.show()

4.2 Key Findings

  • Nintendo DS had higher positive sentiment than PSP, with 61.01% 5-star ratings.
  • PSP users valued multimedia features, while NDS users appreciated exclusive games.
  • Logistic Regression and SVM had the best accuracy (~84%) for sentiment classification.

5. Business Applications of NLP and Sentiment Analysis

5.1 Brand Reputation Management

  • Monitor customer sentiment on social media and reviews.
  • Detect emerging issues and adjust marketing strategies accordingly.

5.2 Market Research and Competitive Analysis

  • NLP can track consumer discussions across platforms to uncover trends.
  • Businesses can compare product reviews, customer satisfaction, and feature preferences.

5.3 Automated Customer Support

  • Chatbots powered by NLP reduce response times and improve customer satisfaction.
  • Sentiment Analysis can help prioritize critical issues in customer feedback.

5.4 Product Development and User Experience Optimization

  • Identify recurring complaints and feature requests from user reviews.
  • Guide R&D teams to develop products based on data-driven insights.

5.5 Social Media Monitoring Case Study

  • Real-time Twitter sentiment analysis using tweepy and nltk: 
    import tweepy
from nltk.sentiment import SentimentIntensityAnalyzer

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

auth = tweepy.OAuth1UserHandler(consumer_key, consumer_secret, access_token, access_token_secret)
api = tweepy.API(auth)

tweets = api.search(q='gaming', count=100)
sia = SentimentIntensityAnalyzer()

for tweet in tweets:
    score = sia.polarity_scores(tweet.text)
    print(tweet.text, score)  # Output: Tweet text and sentiment scores

6. Conclusion

  1. NLP is a powerful AI field that enables machines to understand human language.
  2. Sentiment Analysis is a key application of NLP, providing insights into customer opinions.
  3. The PSP vs. NDS study demonstrated how sentiment analysis can reveal consumer preferences and market trends.
  4. Businesses can leverage these techniques for brand management, market research, and product innovation.

As NLP and AI continue to evolve, their applications in business intelligence, automation, and decision-making will only expand.

← Back to all posts