NLP Sentiment Analysis with Naive Bayes

## Step 1: Import the required Libraries and Load the Dataset from required data

# Import necessary libraries for text processing, machine learning, and data handling
import nltk
from nltk.corpus import movie_reviews
import random
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics import accuracy_score, classification_report

# Download the movie reviews dataset (if not already downloaded)
nltk.download('movie_reviews')

# Fetch the movie reviews dataset provided by nltk
# Each document is a tuple containing a list of words (the review) and its label (positive/negative)
documents = []  
categories = movie_reviews.categories()  

for category in categories:
    fileids = movie_reviews.fileids(category) 
    for fileid in fileids:
        words = list(movie_reviews.words(fileid)) 
        documents.append((words, category))

# Shuffle the documents to ensure the data is randomly ordered for training
random.shuffle(documents)

# Detailed Explanation for Step 1:
# Import libraries, download the movie review dataset, and shuffle it to prepare for training.


# Step 2: Preprocess the Data

# Convert each review's list of words into a single sentence
# This creates a structure suitable for the CountVectorizer
text_data = [" ".join(words) for words, category in documents]  # Join words in each review to form sentences
labels = [category for words, category in documents]             # Extract sentiment labels (positive or negative)

# 80% of the data used for training, the rest will be used for testing purposes
train_data, test_data, train_labels, test_labels = train_test_split(
    text_data, labels, test_size=0.2, random_state=42
)

# Detailed Explanation for Step 2:
# Preprocess the dataset by joining words in each review to form sentences, creating text_data and labels.


# Step 3: Feature Extraction Using CountVectorizer

# Initialize CountVectorizer, which will create a bag-of-words model
# This converts text data into numerical features, where each word represents a unique feature
vectorizer = CountVectorizer()

# Count vectors are fit and the training data is transformed to count vectors. 
# The fit_transform method learns the vocabulary and transforms the training data in one step
X_train_counts = vectorizer.fit_transform(X_train)

# Transform the test data into the same count vector space
# We use transform (not fit_transform) on the test data to ensure it uses the same vocabulary as the training set
X_test_counts = vectorizer.transform(X_test)

# Detailed Explanation for Step 3:
# Use CountVectorizer to convert text into a bag-of-words model, which turns words into numerical features.


# Step 4: Train the Naive Bayes Model

# Initialize the Multinomial Naive Bayes classifier
# This classifier is suitable for data like word counts, as it assumes features are categorical
nb_classifier = MultinomialNB()

# The Classification model is fit and trained with the Training Dataset. 
# The model learns the association between word features and the sentiment label
nb_classifier.fit(X_train_counts, y_train)

# Detailed Explanation for Step 4:
# Train a MultinomialNB classifier on the training data.
# This model is effective for text classification because it calculates probabilities for each word in the context of the label.


# Step 5: Evaluate the Model

# Predictions are made on the test dataset by using the trained model.
y_pred = nb_classifier.predict(X_test_counts)

# Print the accuracy of the model
# Accuracy is the ratio of correctly predicted labels to the total predictions
print("Accuracy:", accuracy_score(y_test, y_pred))

# Print the classification report for detailed metrics
# The report includes precision, recall, and F1-score for each class (positive/negative)
print("Classification Report:\n", classification_report(y_test, y_pred))

# Detailed Explanation for Step 5:
# Evaluate the model using the test set, checking accuracy and other metrics like precision, recall, and F1-score.
# These metrics provide insights into how well the model distinguishes between positive and negative reviews.


# Step 6: Test the Model on New Texts

# Define some new sample reviews to test the model's predictions
# These are unseen examples to check the model's performance in a practical scenario
new_reviews = [
    "The movie is fantastic",
    " It was boring. I did not enjoy the film.",
  
]

# Transform the new reviews into the count vector space using the same vocabulary as training
# This step ensures consistency in feature extraction
new_reviews_counts = vectorizer.transform(new_reviews)

# Predict the sentiment for each of the new reviews
# The model outputs the predicted label (positive/negative) for each review
predictions = nb_classifier.predict(new_reviews_counts)

# Print each review along with its predicted sentiment for interpretation
for review, sentiment in zip(new_reviews, predictions):
    print(f"Review: {review}\nSentiment: {sentiment}\n")

# Detailed Explanation for Step 6:
# Test the model on new, unseen reviews to assess its practical application.
# The predictions show the model's ability to generalize to new data.

from sklearn.feature_extraction.text import TfidfVectorizer

# Use TF-IDF
tfidf_vectorizer = TfidfVectorizer()
X_train_tfidf = tfidf_vectorizer.fit_transform(X_train)
X_test_tfidf = tfidf_vectorizer.transform(X_test)

# Retrain model with TF-IDF features
nb_classifier.fit(X_train_tfidf, y_train)

# Evaluate with TF-IDF
y_pred_tfidf = nb_classifier.predict(X_test_tfidf)
print("TF-IDF Accuracy:", accuracy_score(y_test, y_pred_tfidf))
print("Classification Report (TF-IDF):\n", classification_report(y_test, y_pred_tfidf))