Sentiment Analysis using Fuzzy Logic

Sentiment analysis, also known as opinion mining, is a crucial area of natural language processing (NLP) that involves determining the sentiment expressed in a piece of text. This sentiment can be positive, negative, or neutral. Traditional sentiment analysis methods often rely on machine learning techniques, which require large datasets and extensive training. However, an alternative approach using fuzzy logic can offer a more intuitive and flexible way to handle the inherent uncertainty and vagueness in human language.

In the article, we are going to explore why and how we can use fuzzy logic for sentiment analysis.

What is Fuzzy Logic?

Fuzzy logic, introduced by Lotfi Zadeh in 1965, extends classical logic to handle the concept of partial truth — truth values between "completely true" and "completely false." This is particularly useful in dealing with real-world scenarios where binary true/false values are insufficient to represent the complexity of human reasoning.

In the context of sentiment analysis, fuzzy logic allows us to assign degrees of positivity or negativity to words and phrases, reflecting the subtleties of human emotions and opinions more effectively than traditional binary classifications.

Why Use Fuzzy Logic for Sentiment Analysis?

1. Handling Ambiguity: Fuzzy logic can manage the ambiguity and imprecision inherent in natural language, where words can have different connotations depending on the context.
2. Linguistic Variables: It uses linguistic variables (e.g., "good," "bad," "average") instead of numerical values, making the system more interpretable.
3. Rule-Based Approach: Fuzzy logic employs a rule-based approach, allowing for the incorporation of expert knowledge and heuristic rules into the sentiment analysis process.

Components of a Fuzzy Logic System

A fuzzy logic system for sentiment analysis typically consists of the following components:

1. Fuzzification: Converting input data (text) into fuzzy sets. Words and phrases are mapped to degrees of sentiment (e.g., "happy" might be 0.8 positive, 0.1 negative).
2. Fuzzy Rules: A set of if-then rules that define how different inputs relate to the sentiment output. For example, "IF the word is 'happy' THEN the sentiment is positive."
3. Inference Engine: Applies the fuzzy rules to the fuzzified inputs to generate fuzzy outputs.
4. Defuzzification: Converts the fuzzy output back into a crisp value, such as a sentiment score.

Implementing Fuzzy Logic for Sentiment Analysis

Step 1: Import Necessary Libraries

We start by importing the necessary libraries for handling data, preprocessing text, performing sentiment analysis, and working with fuzzy logic.

import pandas as pd
import numpy as np
import skfuzzy as fuzz
from skfuzzy import control as ctrl
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from textblob import TextBlob
import matplotlib.pyplot as plt
from sklearn.metrics import accuracy_score, classification_report

# Download necessary NLTK data files
nltk.download('stopwords')
nltk.download('punkt')

Step 2: Define Preprocessing Function

This step involves defining a function to preprocess the text data. The function converts text to lowercase, tokenizes it, and removes stopwords.

# Preprocessing function
def preprocess(text):
    text = text.lower()
    words = word_tokenize(text)
    words = [word for word in words if word not in stopwords.words('english')]
    return ' '.join(words)

Step 3: Load and Preprocess Dataset

Load the dataset from a CSV file, then preprocess the text data using the defined function.

# Load dataset
df = pd.read_csv('/content/sentiment_analysis.csv')

# Preprocess texts
df['processed_text'] = df['text'].apply(preprocess)

Step 4: Obtain Sentiment Polarity Scores with TextBlob

Use TextBlob to compute initial sentiment polarity scores for the preprocessed text.

# Use TextBlob to obtain initial sentiment polarity scores
df['textblob_polarity'] = df['processed_text'].apply(lambda text: TextBlob(text).sentiment.polarity)

Step 5: Define Fuzzy Variables

Define fuzzy variables for polarity and sentiment with their respective ranges and membership functions.

# Define fuzzy variables
polarity = ctrl.Antecedent(np.arange(-1, 1.1, 0.1), 'polarity')
sentiment = ctrl.Consequent(np.arange(0, 1.1, 0.1), 'sentiment')

# Membership functions for polarity
polarity['negative'] = fuzz.trimf(polarity.universe, [-1, -1, 0])
polarity['neutral'] = fuzz.trimf(polarity.universe, [-0.5, 0, 0.5])
polarity['positive'] = fuzz.trimf(polarity.universe, [0, 1, 1])

# Membership functions for sentiment
sentiment['negative'] = fuzz.trimf(sentiment.universe, [0, 0, 0.3])
sentiment['neutral'] = fuzz.trimf(sentiment.universe, [0.2, 0.5, 0.7])
sentiment['positive'] = fuzz.trimf(sentiment.universe, [0.5, 1, 1])

Step 6: Define Fuzzy Rules

Define the fuzzy logic rules to map the polarity to the corresponding sentiment.

# Fuzzy rules
rule1 = ctrl.Rule(polarity['positive'], sentiment['positive'])
rule2 = ctrl.Rule(polarity['negative'], sentiment['negative'])
rule3 = ctrl.Rule(polarity['neutral'], sentiment['neutral'])

Step 7: Create and Simulate Fuzzy Control System

Create a fuzzy control system and simulate it to evaluate the sentiment based on the polarity scores.

# Control system
sentiment_ctrl = ctrl.ControlSystem([rule1, rule2, rule3])
sentiment_sim = ctrl.ControlSystemSimulation(sentiment_ctrl)

# Evaluate sentiment using fuzzy logic
fuzzy_sentiments = []
for polarity_score in df['textblob_polarity']:
    sentiment_sim.input['polarity'] = polarity_score
    try:
        sentiment_sim.compute()
        fuzzy_sentiments.append(sentiment_sim.output['sentiment'])
    except:
        fuzzy_sentiments.append(np.nan)  # Assign NaN if computation fails

df['fuzzy_sentiment_score'] = fuzzy_sentiments

Step 8: Handle Missing Values and Map Sentiment Scores

Handle cases where sentiment computation fails by assigning a neutral score. Then map the fuzzy sentiment score to sentiment labels.

# Handle cases where sentiment could not be computed
df['fuzzy_sentiment_score'].fillna(0.5, inplace=True)  # Assign a neutral score if NaN

# Map the fuzzy sentiment score to sentiment labels
def map_sentiment(score):
    if score <= 0.4:
        return 'negative'
    elif score >= 0.6:
        return 'positive'
    else:
        return 'neutral'

df['fuzzy_sentiment'] = df['fuzzy_sentiment_score'].apply(map_sentiment)

Step 9: Evaluate and Visualize the Results

Evaluate the performance of the fuzzy sentiment classification using a classification report and visualize the membership functions.

# Evaluate the model
report = classification_report(df['sentiment'], df['fuzzy_sentiment'], target_names=['negative', 'neutral', 'positive'])
print(report)

# Visualize the membership functions
polarity.view()
sentiment.view()

By following these steps, you can implement a fuzzy logic-based sentiment analysis system that processes text data, evaluates sentiment polarity using TextBlob, and refines the sentiment classification using a fuzzy control system.

Complete Code

import pandas as pd
import numpy as np
import skfuzzy as fuzz
from skfuzzy import control as ctrl
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from textblob import TextBlob
import matplotlib.pyplot as plt
from sklearn.metrics import accuracy_score, classification_report


nltk.download('stopwords')
nltk.download('punkt')


def preprocess(text):
    text = text.lower()
    words = word_tokenize(text)
    words = [word for word in words if word not in stopwords.words('english')]
    return ' '.join(words)


df = pd.read_csv('/content/sentiment_analysis.csv')


df['processed_text'] = df['text'].apply(preprocess)


df['textblob_polarity'] = df['processed_text'].apply(lambda text: TextBlob(text).sentiment.polarity)


polarity = ctrl.Antecedent(np.arange(-1, 1.1, 0.1), 'polarity')
sentiment = ctrl.Consequent(np.arange(0, 1.1, 0.1), 'sentiment')


polarity['negative'] = fuzz.trimf(polarity.universe, [-1, -1, 0])
polarity['neutral'] = fuzz.trimf(polarity.universe, [-0.5, 0, 0.5])
polarity['positive'] = fuzz.trimf(polarity.universe, [0, 1, 1])

sentiment['negative'] = fuzz.trimf(sentiment.universe, [0, 0, 0.3])
sentiment['neutral'] = fuzz.trimf(sentiment.universe, [0.2, 0.5, 0.7])
sentiment['positive'] = fuzz.trimf(sentiment.universe, [0.5, 1, 1])

rule1 = ctrl.Rule(polarity['positive'], sentiment['positive'])
rule2 = ctrl.Rule(polarity['negative'], sentiment['negative'])
rule3 = ctrl.Rule(polarity['neutral'], sentiment['neutral'])

sentiment_ctrl = ctrl.ControlSystem([rule1, rule2, rule3])
sentiment_sim = ctrl.ControlSystemSimulation(sentiment_ctrl)

fuzzy_sentiments = []
for polarity_score in df['textblob_polarity']:
    sentiment_sim.input['polarity'] = polarity_score
    try:
        sentiment_sim.compute()
        fuzzy_sentiments.append(sentiment_sim.output['sentiment'])
    except:
        fuzzy_sentiments.append(np.nan)  

df['fuzzy_sentiment_score'] = fuzzy_sentiments


df['fuzzy_sentiment_score'].fillna(0.5, inplace=True)

def map_sentiment(score):
    if score <= 0.4:
        return 'negative'
    elif score >= 0.6:
        return 'positive'
    else:
        return 'neutral'

df['fuzzy_sentiment'] = df['fuzzy_sentiment_score'].apply(map_sentiment)

report = classification_report(df['sentiment'], df['fuzzy_sentiment'], target_names=['negative', 'neutral', 'positive'])
print(report)
polarity.view()
sentiment.view()

Output:

               precision    recall  f1-score   support

    negative       0.77      0.33      0.46       134
     neutral       0.55      0.84      0.66       200
    positive       0.75      0.62      0.68       165

    accuracy                           0.63       499
   macro avg       0.69      0.60      0.60       499
weighted avg       0.68      0.63      0.61       499

As we can see the dip in recall of negative sentiments is due to imbalanced dataset. The 63% accuracy can be regarded as good in sentiment analysis because texts can be of different sentiments.

Advantages and Challenges

Advantages

• Interpretability: The use of linguistic variables and rules makes the system more understandable to humans.
• Flexibility: Easily incorporates new rules and adjusts existing ones based on expert knowledge or new data.
• Robustness: Handles uncertainty and partial truths effectively, providing more nuanced sentiment analysis.

Challenges

• Rule Definition: Creating a comprehensive set of rules can be time-consuming and requires domain expertise.
• Scalability: Fuzzy logic systems may become complex and harder to manage as the number of rules increases.
• Subjectivity: Assigning sentiment scores and defining rules can be subjective and vary among different individuals.

Conclusion

Fuzzy logic offers a powerful and flexible approach to sentiment analysis, addressing some of the limitations of traditional machine learning methods. By leveraging the ability to handle uncertainty and vagueness, fuzzy logic can provide more nuanced and interpretable sentiment analysis, making it a valuable tool for understanding human emotions and opinions expressed in text. As AI and NLP technologies continue to evolve, integrating fuzzy logic into sentiment analysis systems could enhance their effectiveness and broaden their application in various fields.