UNIT IV: Tools and Applications of Data Science: Introducing Neo4j for dealing with graph databases,

graph query language Cypher, Applications graph databases, Python libraries like nltk and SQLite for
handling Text mining and analytics, case study on classifying Reddit posts.

Introducing Neo4jfor dealing with graph data

Neo4j is one of the most popular graph databases used to handle data with complex, interconnected
relationships. Unlike traditional relational databases, which use tables to store data, Neo4j is based on a
graph model, which makes it well-suited for data where connections between entities are just as important as
the entities themselves. Here's an overview of Neo4j and why it’s useful in working with graph data:

Key Features of Neo4j

1. Graph Data Model: Neo4j stores data as nodes, relationships, and properties, which allows it to
intuitively map out and store complex relationships.
2. Cypher Query Language: Neo4j uses Cypher, a declarative query language optimized for querying
graph data. Cypher's syntax is designed to resemble the structure of graphs, making it relatively easy to
query and manipulate relationships.
3. Efficient Traversals: Neo4j is designed for fast traversal of large graphs. This is particularly useful in
scenarios where data relationships need to be analyzed, such as social networks, fraud detection,
recommendation engines, and knowledge graphs.
4. Scalability and High Availability: Neo4j is built to scale both vertically (by adding more
memory/CPU) and horizontally (by clustering) to handle large data volumes. It supports replication and
clustering to ensure high availability.
Key Concepts in Neo4j
• Nodes: Represent entities such as documents, users, recipes, and so on (e.g., people, places,
products).
• Relationships: Define how nodes are related to each other. Every relationship has a name and a
direction, which together provide semantic context for the nodes connected by the relationship. (e.g.,
"FRIENDS_WITH," "PURCHASED").
• Properties: Attributes that add context to nodes and relationships. Properties are defined by key-
value pairs. (e.g., names, dates, locations).
• Labels —Can be used to group similar nodes to facilitate faster traversal through graphs.
There are some unique features that will make you choose Neo4j over any other Database Management
System. Neo4j is surrounded by relationships but there is no need to set up primary key or foreign key
constraints to any data. Here you can add any relation between any nodes you want. That makes the Neo4j
extremely suited for Networking data, below is the list of data areas where you can use this Database
Management System.
• Social network analysis like in Facebook, Twitter or in Instagram
• Network Diagram
• Fraud Detection
• Graph based searched of digital assets
• Data Management
• Real-time product recommendation
Figure: The graph drawn has been created in the Neo4j web interface. The nodes aren’t represented by their
labels but by their names.

When are graph databases not suitable?

A dedicated graph database provides the most value for highly connected datasets and any analyses that
require searching for hidden and apparent relationships. If this doesn’t fit your use case, other database types
may be better suited.

For example, imagine a scenario where you need to record product inventory by item. You only need to
store details like item name and available units. Since you don’t need to retain additional information, the
columns on the table will not change. Due to the tabular nature, a relational database is better suited for such
unrelated data.

Graph Query Language Cypher

Cypher is the declarative query language used in Neo4j, one of the most popular graph databases. It is
designed to allow users to efficiently query and update the graph data stored in Neo4j. Cypher’s syntax is
simple and expressive, resembling SQL but adapted for graph structures, which makes it intuitive for those
familiar with relational databases.

Key Concepts in Cypher:

1. Nodes and Relationships:

o Nodes are represented using parentheses, e.g., (n).
o Relationships are represented with arrows, e.g., ()-[r]->() for directed relationships.
2. Basic Query Structure:
o MATCH: Used to find patterns in the data.
o WHERE: Adds conditions to filter results.
o RETURN: Specifies what to return from the query.
o CREATE: Adds new nodes and relationships.
o MERGE: Ensures patterns exist; if not, it creates them.
 o SET: Updates properties of nodes or relationships.
o DELETE: Removes nodes or relationships.

Sample Queries
1) Find a simple path between nodes:
MATCH (a:Person {name: 'Alice'})-[r:FRIEND*1..3]->(b:Person) RETURN a, r, b
2) Create a new node and relationship:
CREATE (p:Person {name: 'Bob', age: 30})
CREATE (p)-[:FRIEND]->(:Person {name: 'Charlie'})
3) Update a property:
MATCH (p:Person {name: 'Bob'}) SET p.age = 31
4) Delete a node:
MATCH (p:Person {name: 'Charlie'}) DETACH DELETE p
Examples of Cypher Queries

a. Find Nodes and Relationship

Suppose you have a graph representing people and their friendships
MATCH (a:Person {name: 'Alice'})-[:FRIEND]->(b:Person) RETURN a, b
This query matches nodes labeled Person where Alice has a FRIEND relationship to another Person. It
returns Alice and her friends.
b. Create Nodes and Relationships
To create a new person node and establish a friendship:
CREATE (p:Person {name: 'John', age: 28})
CREATE (p)-[:FRIEND]->(:Person {name: 'Diana', age: 27})
This query creates two Person nodes (John and Diana) and a FRIEND relationship from John to Diana.
c. Add Properties to Existing Nodes
If you want to update a property on a node:
MATCH (p:Person {name: 'John'}) SET p.city = 'New York'
MATCH (p:Person {name: 'John'}) SET p.city = 'New York'
This finds the node labeled Person with the name 'John' and adds or updates the city property.
d. Find Nodes with Conditional Filters
To find people over a certain age:
MATCH (p:Person) WHERE p.age > 25 RETURN p.name, p.age
This returns the names and ages of all Person nodes whose age property is greater than 25.
a. Delete Nodes and Relationships
To remove a node and its relationships:
MATCH (p:Person {name: 'Diana'}) DETACH DELETE p
The DETACH DELETE clause removes a node and all relationships attached to it
b. Merge: Create or Match Existing
To ensure a relationship or node exists:
MERGE (p:Person {name: 'Emma'})
MERGE (p)-[:FRIEND]->(q:Person {name: 'Oliver'})
If Emma or Oliver don’t already exist, they will be created. If the relationship doesn’t exist, it will be
created.
g)Traversal with Variable Length Paths To find relationships of varying lengths:
MATCH (a:Person {name: 'Alice'})-[r:FRIEND*1..3]->(b:Person) RETURN a, r, b
This matches FRIEND relationships between Alice and other Person nodes, allowing for 1 to 3 hops (i.e.,
friends, friends of friends, and so on).

Python libraries like nltk and SQLite for handling Text mining and analytics

Text mining or text analytics is a discipline that combines language science and computer science with
statistical and machine learning techniques. Text mining is used for analysing texts and turning them into a
more structured form. Then it takes this structured form and tries to derive insights from it.

When analysing crime from police reports, for example, text mining helps you recognize persons, places,
and types of crimes from the reports. Then this new structure is used to gain insight into the evolution of
crimes.

Text mining in the real world:

In your day-to-day life you’ve already come across text mining and natural language applications.
Autocomplete and spelling correctors are constantly analysing the text you type before sending an email or
text message. When Facebook autocompletes your status with the name of a friend, it does this with the help
of a technique called named entity recognition. The goal isn’t only to detect that you’re typing a noun, but
also to guess you’re referring to a person and recognize who it might be. Another example of named entity
recognition is shown in figure 8.2. Google knows Chelsea is a football club but responds differently when
asked for a person.
Google uses text mining for much more than answering queries. Next to shielding its Gmail users from
spam, it also divides the emails into different categories such as social, updates, and forums, as shown in
figure 8.3.

Text mining and Analytics allows for the creation of automatic reasoning engines driven by natural language
queries. Figure 8.4 shows how “Wolfram Alpha,” a computational knowledge engine, uses text mining and
automatic reasoning to answer the question “Is the USA population bigger than China?”
The IBM Watson astonished many in 2011 when the machine was set up against two human players in a
game of Jeopardy. Jeopardy is an American quiz show where people receive the answer to a question and
points are scored for guessing the correct question for that answer. See figure 8.5. It’s safe to say this round
goes to artificial intelligence. IBM Watson is a cognitive engine that can interpret natural language and
answer questions based on an extensive knowledge base.
Text mining has many applications, including, but not limited to, the following:

 Entity identification
 Plagiarism detection
 Topic identification
 Text clustering
 Translation
 Automatic text summarization
 Fraud detection
 Spam filtering
 Sentiment analysis

In reality text mining is a complicated task and even many seemingly simple things can’t be done
satisfactorily. For instance, take the task of guessing the correct address. Figure 8.6 shows how difficult it is
to return the exact result with certitude and how Google Maps prompts you for more information when
looking for “Springfield.” In this case a human wouldn’t have done any better without additional context,
but this ambiguity is one of the many problems you face in a text mining application.

Another problem is spelling mistakes and different (correct) spelling forms of a word. Take the following
three references to New York: “NY,” “Neww York,” and “New York.” For a human, it’s easy to see they all
refer to the city of New York
 Text mining techniques
Bag of words:

Bag of words is the simplest way of structuring textual data: every document is turned into a word vector. If
a certain word is present in the vector it’s labelled “True”; the others are labelled “False”. Figure 8.7 shows
a simplified example of this, in case there are only two documents: one about the television show Game of
Thrones and one about data science. The two word vectors together form the document-term matrix. The
document-term matrix holds a column for every term and a row for every document. The values are yours to
decide upon. In this chapter we’ll use binary: term is present? True or False.
Before getting to the actual bag of words, many other data manipulation steps take place:
 Tokenization—The text is cut into pieces called “tokens” or “terms.” These tokens are the most basic
unit of information you’ll use for your model. The terms are often words but this isn’t a necessity.
Entire sentences can be used for analysis. We’ll use unigrams: terms consisting of one word. Often,
however, it’s useful to include bigrams (two words per token) or trigrams (three words per token) to
capture extra meaning and increase the performance of your models.
 Stop word filtering—Every language comes with words that have little value in text analytics
because they’re used so often. NLTK comes with a short list of English stop words we can filter. If
the text is tokenized into words, it often makes sense to rid the word vector of these low-information
stop words.
 Lowercasing—Words with capital letters appear at the beginning of a sentence, others because
they’re proper nouns or adjectives. We gain no added value making that distinction in our term
matrix, so all terms will be set to lowercase.

Stemming and lemmatization:

Stemming is the process of bringing words back to their root form; this way you end up with less
variance in the data. This makes sense if words have similar meanings but are written differently because,
for example, one is in its plural form. Stemming attempts to unify by cutting off parts of the word. For
example, “planes” and “plane” both become “plane.”
Another technique, called lemmatization, has this same goal but does so in a more grammatically
sensitive way. For example, while both stemming and lemmatization would reduce “cars” to “car,”
lemmatization can also bring back conjugated verbs to their unconjugated forms such as “are” to “be.”
Which one you use depends on your case, and lemmatization profits heavily from POS Tagging (Part of
Speech Tagging).
POS Tagging is the process of attributing a grammatical label to every part of a sentence. You probably did
this manually in school as a language exercise. Take the sentence “Game of Thrones is a television series.”
If we apply POS Tagging on it, we get
({“game”:”NN”},{“of”:”IN},{“thrones”:”NNS},{“is”:”VBZ},{“a”:”DT},{“television”:”NN},
{“series”:”NN})

NN is a noun, IN is a preposition, NNS is a noun in its plural form, VBZ is a third-person singular verb, and
DT is a determiner. Table 8.1 has the full list
POS Tagging is a use case of sentence-tokenization rather than word-tokenization. After the POS Tagging is
complete you can still proceed to word tokenization, but a POS Tagger requires whole sentences. Combining
POS Tagging and lemmatization is likely to give cleaner data than using only a stemmer.

Decision tree classifier

The decision tree classifier actively creates interaction variables and buckets. An interaction variable
is a variable that combines other variables. For instance, “data” and “science” might be good predictors in
their own right but probably the two of them co-occurring in the same text might have its own value. A
bucket is somewhat the opposite. Instead of combining two variables, a variable is split into multiple new
ones. This makes sense for numerical variables. Figure 8.8 shows what a decision tree might look like and
where you can find interaction and bucketing.
Let’s say an ultrasound at 12 weeks’ pregnancy has a 90% accuracy in determining the gender of the baby.
A 10% uncertainty still exists, but the ultrasound did reduce the uncertainty from 50% to 10%. That’s a
pretty good discriminator. A decision tree follows this same principle, as shown in figure 8.9

Overfitting allows the model to mistake randomness for real correlations. To counteract this, a decision tree
is pruned: its meaningless branches are left out of the final model.

The Python packages we’ll use in this chapter:

 NLTK—For text mining

 PRAW—Allows downloading posts from Reddit
 SQLite3—Enables us to store data in the SQLite format
 Matplotlib—A plotting library for visualizing data

Features of NLP in Python

Natural Language Processing (NLP) in Python comes with a wide range of features and capabilities, made
possible by powerful libraries like nltk, spaCy, TextBlob, and transformers. Here are some key features:
1. Tokenization
• Breaking text into sentences or words.
• Useful for pre-processing text for further analysis.
• Libraries: nltk, spaCy, TextBlob.
2. Part-of-Speech (POS) Tagging
• Assigning grammatical tags (e.g., noun, verb, adjective) to each word in a sentence.
• Helps understand the structure and context of the text.
• Libraries: nltk, spaCy.
3. Named Entity Recognition (NER)
• Identifying and classifying entities such as names of people, places, dates, and
organizations in text.
• Useful for extracting valuable information from documents.
• Libraries: spaCy, nltk.
4. Stopword Removal
• Filtering out common words (e.g., “the”, “is”, “and”) that do not contribute significant
meaning.
• Improves the focus on keywords that matter.
• Libraries: nltk, spaCy.
5. Stemming and Lemmatization
• Reducing words to their base forms:
o Stemming removes affixes (e.g., "running" → "run").
o Lemmatization returns the dictionary form (e.g., "running" → "run" and "better" →
"good").
• Libraries: nltk, spaCy.
6. Sentiment Analysis
 • Determining the sentiment (e.g., positive, negative, neutral) expressed in a piece of text.
• Common in applications like social media monitoring, reviews analysis.
• Libraries: TextBlob, nltk, VADER (for social media).
7. Text Classification
• Categorizing text into predefined categories.
• Used for spam detection, topic classification, etc.
• Libraries: scikit-learn, nltk.
8. Word Embeddings and Vectorization
• Converting text into numerical representations that capture the context and meaning:
o Bag-of-Words (BoW), TF-IDF for simpler vectorization.

o Word2Vec, GloVe, and transformer-based embeddings for capturing complex

semantic relationships.
• Libraries: gensim, spaCy, transformers.

9. Text Summarization
• Creating a summary of longer pieces of text to extract the main points.
• Available as extractive or abstractive summarization techniques.
• Libraries: nltk, sumy, transformers.
10. Language Translation
• Translating text between different languages using NLP models.
• Advanced transformer models like Hugging Face's transformers provide robust translation
capabilities.
• Libraries: transformers, Google Translate API.
11. Speech Recognition and Generation
• Converting speech to text and vice versa.
• Enables applications like virtual assistants and automated transcription services.
• Libraries: speech_recognition, gTTS for text-to-speech.
12. Topic Modeling
• Identifying underlying topics in a collection of documents.
• Common techniques include Latent Dirichlet Allocation (LDA) and Non- Negative Matrix
Factorization (NMF).
• Libraries: gensim, scikit-learn.
13. Coreference Resolution
• Identifying expressions that refer to the same entity in a text.
• Improves the understanding of complex sentences and pronoun references.
• Libraries: spaCy with the neuralcoref extension.
14. Dependency Parsing
• Analyzing the grammatical structure of a sentence and establishing relationships between
"head" words and words that modify those heads.
• Useful for understanding sentence construction and syntactic dependencies.
• Libraries: spaCy, nltk.
15. Machine Translation and Advanced NLP Tasks
• Using transformer-based models for sophisticated tasks like:
o Question answering, language modeling, text generation.
• Libraries: transformers, OpenAI GPT.
These features empower Python developers to build comprehensive NLP solutions for diverse applications,
from chatbots to text analysis and data mining.
NLP – Natural Language Preocessing How to write nltk programming

1. pip install nltk

2. import nltk
3. nltk.download("all")

4. from nltk.tokenize import word_tokenize

text = "This is an example sentence." words = word_tokenize(text) print(words)

from nltk import pos_tag

from nltk.tokenize import word_tokenize

text = "This is an example sentence." words = word_tokenize(text)

pos = pos_tag(words) print(pos)

5. Explanation of Tags:
I : PRP
NNP: Proper noun (e.g., "Python") NN: Noun (e.g., "programming")
VBZ: Verb, 3rd person singular present (e.g., "is") JJ: Adjective (e.g., "fun", "educational")
CC: Coordinating conjunction (e.g., "and")

POS Tags:
[('Python', 'NNP'), ('programming', 'NN'), ('is', 'VBZ'), ('fun', 'JJ'), ('and', 'CC'), ('educational', 'JJ'), ('.', '.')]

NLTK (Natural Language Toolkit) and SQLite are powerful tools for handling text mining and analytics
tasks.
NLTK: A comprehensive library for natural language processing.
 Tokenization:
import nltk
nltk.download('punkt')
from nltk.tokenize import word_tokenize
text = "Hello, how are you?"
tokens = word_tokenize(text)
print(tokens)
SQLite: A lightweight, disk-based database that doesn't require a separate server process.
 Basic SQLite Operations:

import sqlite3
conn = sqlite3.connect('example.db')
c = conn.cursor()
c.execute('''CREATE TABLE posts (id INTEGER PRIMARY KEY, title TEXT, content TEXT)''')
c.execute("INSERT INTO posts (title, content) VALUES ('First Post', 'This is the content')")
conn.commit()

import nltk
from nltk.tokenize import word_tokenize from nltk.corpus import stopwords
from collections import Counter

# Download required NLTK datasets nltk.download('punkt') nltk.download('stopwords')

# Sample text to process

text = "abc xyz abc xyz def"

# Tokenize the text

words = word_tokenize(text) print("Tokenized words:", words)

# Convert words to lowercase for uniformity words = [word.lower() for word in words]

# Filter out punctuation

words = [word for word in words if word.isalnum()]

# Remove stopwords
stop_words = set(stopwords.words('english'))
filtered_words = [word for word in words if word not in stop_words] print("Filtered words:",
filtered_words)
# Perform word frequency analysis word_counts = Counter(filtered_words) print("Word frequency:",
word_counts)
What is Reddit

Reddit is a social media platform and online community where registered users can post, share, and discuss
content on a vast range of topics. It operates as a network of communities known as subreddits, each
focusing on a specific subject such as technology, sports, entertainment, science, or niche interests.

Users can create posts in the form of text, links, images, or videos, and other members can comment on and
upvote or downvote these posts. The upvote and downvote system helps surface popular content to the top
of the subreddit or Reddit’s main feed, making it more visible to users.

Each subreddit has its own rules and moderators, allowing for a tailored experience and community-driven
management. With its wide variety of content and discussions, Reddit is often called the "front page of the
internet."
Case Study: Classifying Reddit Posts Using Natural Language Processing (NLP)

Introduction Reddit, often termed the "front page of the internet," comprises numerous user-generated
posts across a myriad of communities (subreddits). Each subreddit has unique themes, which makes it a
prime source for textual data analysis. This case study delves into the process of classifying Reddit posts
into relevant subreddits using NLP techniques.
Objective The primary objective of this study was to build a model capable of accurately classifying posts
into their corresponding subreddits based on post titles and content. This could enhance content filtering,
moderation, and search relevance.
Data Collection
• Source: Data was gathered using the Reddit API (PRAW) over a three- month period.
• Volume: The dataset included approximately 100,000 posts spanning diverse subreddits such as
technology, sports, health, and entertainment.
• Preprocessing Steps:
o Text Cleaning: Removal of URLs, special characters, and stopwords.
o Normalization: Lowercasing all text.
o Tokenization: Splitting text into meaningful units.
o Lemmatization: Converting words to their base forms.
Methodology
1. Feature Engineering:
o Used TF-IDF (Term Frequency-Inverse Document Frequency) for feature representation.
o Employed word embeddings (e.g., Word2Vec) for advanced context capture.
2. Modeling Techniques:
o Baseline Model: Multinomial Naive Bayes for initial insights.
o Advanced Models: Utilized logistic regression, support vector machines (SVM), and fine-tuned
BERT (Bidirectional Encoder Representations from Transformers) for higher accuracy.
3. Evaluation Metrics:
o Employed accuracy, precision, recall, and F1-score to measure performance.
o BERT outperformed others with an F1-score of 0.92.
Results The BERT-based model successfully classified posts with high accuracy and robustness across
different subreddits. Key insights included:
• Posts with short, ambiguous titles performed better with BERT due to its contextual understanding.
TF-IDF with logistic regression provided a strong baseline but struggled with nuanced classifications.
Challenges and Solutions
• Imbalanced Classes: Some subreddits had significantly more posts. Solution: Applied SMOTE
(Synthetic Minority Oversampling Technique) for balancing.
• Computational Complexity: Training BERT required significant resources. Solution: Used cloud-based
GPUs to expedite processing.
Conclusion Classifying Reddit posts is a complex yet achievable task with the right blend of data
preprocessing and advanced NLP models. The case study demonstrated that while simpler models can
provide reasonable results, transformer models like BERT deliver superior performance for nuanced
classifications.
Future Work Further enhancements could include:
• Expanding the dataset to incorporate more subreddits.
• Exploring multi-modal approaches by integrating metadata or user behavior patterns.
• Deploying the model in real-time for subreddit recommendation or moderation support.

*******************************
Reddit has several key features that contribute to its popularity and functionality as an online platform. Here
are the main features:
1. Subreddits
• Definition: Dedicated communities within Reddit that focus on specific topics, ranging from general
(e.g., r/technology) to highly niche interests (e.g., r/rarepuppers).
• Customization: Users can subscribe to subreddits that match their interests to create a personalized
feed.
2. Post Types
• Text Posts: Users can share ideas, stories, or questions in a text format.
• Link Posts: Allows users to share links to external content like news articles, videos, or other media.
• Image and Video Posts: Users can upload and share images or videos directly on Reddit.
• Polls: Some subreddits allow users to create interactive polls.
3. Upvotes and Downvotes
• Voting System: Users can upvote or downvote posts and comments. Content with higher upvotes
rises to the top of the subreddit or site-wide trending lists, while heavily downvoted content becomes
less visible.
• Karma: Users earn “karma” points based on the upvotes their posts and comments receive,
reflecting their contributions to the platform.

4. Commenting and Discussions

• Threaded Comments: Users can engage in conversations through nested comment threads, allowing
for in-depth discussions.
• Sorting Options: Comments can be sorted by best, newest, oldest, or controversial, helping users
find relevant discussions.
5. Awards and Badges
• Reddit Coins: Users can purchase coins to give awards, such as Silver, Gold, and Platinum, to posts
and comments as a way of appreciating content.
• Community Awards: Custom awards created by subreddit moderators to reward specific types of
contributions.
6. Moderation and Rules
• Moderators (Mods): Volunteers who manage subreddits by setting rules, approving or removing
posts, and ensuring discussions follow community guidelines.
• Automated Tools: Features like AutoModerator help manage spam and enforce rules automatically.
7. User Profiles and Customization
• Profiles: Users can create profiles that display their post history, karma, and other personalized
information.
• Customization: Users can add profile banners and other visual elements.
8. Reddit Premium
• Ad-Free Experience: A paid subscription that removes ads.
• Additional Features: Includes monthly coins to give awards, access to r/lounge (an exclusive
subreddit), and enhanced site features.
9. Reddit Chat and Messaging
• Private Messages: Users can send private messages to other Redditors.
• Chat Rooms: Some subreddits have real-time chat rooms for community interaction.
10. Trending and Popular Feeds
• Explore: Shows trending topics across Reddit.
• Front Page: Aggregates popular content from the subreddits to which a user is subscribed.
11. Search Functionality
Advanced Search: Users can search for specific posts, subreddits, or users, with filters for relevance, time
frame, and type of content.
Classify Reddit posts into different categories using text mining techniques and machine learning.

import praw
import nltk
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score, classification_report

# Initialize Reddit API

reddit=praw.Reddit(client_id='CLIENT_ID',client_secret='CLIENT_SECRET',user_agent='USER_AGE
NT')

# Collect posts from a subreddit

posts = []
for submission in reddit.subreddit('dataisbeautiful').hot(limit=100):
posts.append(submission.title)

# Preprocess text data

nltk.download('stopwords')
stopwords = set(nltk.corpus.stopwords.words('english'))
vectorizer = TfidfVectorizer(stop_words=stopwords)
X = vectorizer.fit_transform(posts)

# Dummy labels for illustration

y = [1 if 'data' in post else 0 for post in posts]

# Split data 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)

# Train a Naive Bayes classifier

model = MultinomialNB()
model.fit(X_train, y_train)

# Make predictions and evaluate

y_pred = model.predict(X_test)
print(f'Accuracy: {accuracy_score(y_test, y_pred)}')
print(classification_report(y_test, y_pred))