Spam Email Detection

College Code & Name 3135 - Panimalar Engineering College Chennai City Campus
Subject Code & Name NM1090 - Natural Language Processing (NLP) Techniques
Year and Semester III Year - VI Semester
Project Team ID

Project Created by 1.

2.

3.

4.

1
 BONAFIDE CERTIFICATE

Certified that this Naan Mudhalvan project report “Spam Email

Detection” is the bonafide work of __________________who carried

out the project work under my supervision.

SIGNATURE SIGNATURE
Project Coordinator SPoC
Naan Mudhalvan Naan Mudhalvan

INTERNAL EXAMINER EXTERNAL EXAMINER

2
 ABSTRACT

The increasing volume of unsolicited and harmful emails, commonly known as

spam, poses significant challenges to both individuals and organizations in managing
their email communications. Spam email detection has thus become a critical task to
maintain email security, enhance productivity, and reduce the risk of cyber threats
such as phishing, malware, and identity theft. This project aims to develop an effective
spam email detection system using machine learning techniques to classify emails as
spam or legitimate. The system leverages various features extracted from the email
content, including the subject, body text, sender information, and metadata. Several
machine learning algorithms, including Naive Bayes, Support Vector Machines (SVM),
and Random Forest, are employed and compared for their effectiveness in accurately
classifying emails.
The dataset used for training and evaluation includes a wide variety of emails,
both legitimate and spam. The project also explores techniques like feature
extraction, text preprocessing, and natural language processing (NLP) to improve
classification performance. The end goal of this project is to build an efficient spam
filter capable of reducing the amount of unwanted and potentially harmful emails,
thereby ensuring a cleaner, safer, and more efficient email communication
experience.

3
 TABLE OF CONTENT

CHAPTER NO TITLE PAGE NO

ABSTRACT 3

1 INTRODUCTION 5

2 TECHNOLOGIES USED 6

3 PROJECT IMPLEMENTATION 11

4 CODING 15

5 TESTING AND OPTIMIZATION 17

6 SAMPLE OUTPUT 21

7 CONCLUSION 22

REFERENCES 23

4
 CHAPTER 1
INTRODUCTION

In the digital age, email has become one of the primary modes of
communication, both for personal and professional purposes. However, alongside
legitimate messages, a large volume of unsolicited and often malicious emails,
commonly known as spam, has been flooding inboxes worldwide. Spam emails not only
clutter inboxes but also pose serious risks, such as phishing attacks, malware
distribution, and identity theft, which can result in significant financial and reputational
damage.
The need for efficient spam email detection has never been more critical.
Traditional methods, such as blacklists and rule-based filtering, have proven to be
insufficient in handling the evolving tactics of spammers. Therefore, there has been a
growing interest in developing automated systems that can intelligently classify emails
as either spam or legitimate. Machine learning, with its ability to learn patterns from
data, offers a promising approach to tackle this challenge.
Spam email detection systems use algorithms to analyze various characteristics of
emails, such as the content of the subject line, body text, sender's address, and
metadata. By extracting relevant features from these components, these systems can be
trained to identify the subtle patterns and signatures that differentiate spam from
legitimate emails. With continuous advancements in natural language processing (NLP)
and machine learning techniques, modern spam filters are becoming increasingly
accurate and capable of handling vast amounts of data in real time.
This project focuses on implementing a robust spam email detection system by
utilizing machine learning techniques to classify emails effectively. The goal is to build a
model that can accurately identify spam emails while minimizing false positives,
ensuring a smoother and safer email experience for users.

5
 CHAPTER 2
TECHNOLOGIES USED

Spam email detection relies on a combination of technologies and techniques to

accurately identify and filter out unwanted messages. These technologies include:
1. Machine Learning Algorithms:
o Naive Bayes: This probabilistic classifier uses the frequency of words and
other features in emails to determine whether an email is spam or not.
o Support Vector Machines (SVM): A supervised machine learning algorithm
that classifies emails based on the separation between spam and non-spam
(ham) categories.
o Decision Trees: These use a tree-like structure to make decisions about
whether an email is spam based on various features.
2. Natural Language Processing (NLP):
o NLP techniques analyze the text content of emails, identifying patterns or
suspicious phrases typical in spam messages. It can process features like
sentiment, tokenization, part-of-speech tagging, and word frequency.
3. Heuristic Rules:
o Heuristic-based filters look for specific patterns such as unusual subject lines,
suspicious links, and spammy keywords or phrases (e.g., "buy now," "free
money").
4. Blacklists and Whitelists:
o Blacklists contain known IP addresses, domains, or email addresses
associated with spammers.
Whitelists include trusted sources to ensure legitimate emails are not flagged as
spam

6
5. Natural Language Processing (NLP) Techniques
 Tokenization: Breaking down legal texts into smaller units such as words,
phrases, or sentences to facilitate processing.
 Part-of-Speech (POS) Tagging: Identifying the grammatical structure of sentences
(e.g., nouns, verbs, adjectives) to understand the context and meaning.
 Named Entity Recognition (NER): Detecting and classifying entities such as
names of parties, dates, statutes, and legal terms, which are critical in legal
documents.
 Sentence Embedding: Converting sentences into numerical vectors to capture
their semantic meaning and enable similarity comparisons.
 Dependency Parsing: Analyzing the grammatical structure of sentences to
identify relationships between words, which is particularly useful for
understanding complex legal sentences.
6. Machine Learning Models
 Pre-trained Transformer Models:
o BERT (Bidirectional Encoder Representations from Transformers): A
transformer-based model that excels in understanding context by
analyzing text bidirectional. It is particularly effective for extractive
summarization tasks.
o GPT (Generative Pre-trained Transformer): A generative model that can
produce coherent and contextually relevant text, making it suitable for
abstractive summarization.
o T5 (Text-to-Text Transfer Transformer): A versatile model that treats all
NLP tasks as a text-to-text problem, enabling both extractive and
abstractive summarization.

7
  Fine-Tuning: Pre-trained models are fine-tuned on legal datasets to adapt them
to the specific language and structure of legal documents. This ensures that the
models can accurately capture domain-specific nuances.
 Sequence-to-Sequence Models: Used for abstractive summarization, these
models generate new sentences that convey the core meaning of the original
text.
7. Libraries and Frameworks
 Hugging Face Transformers: A popular library that provides pre-trained models
like BERT, GPT, and T5, along with tools for fine-tuning and inference.
 SpaCy: An NLP library used for tokenization, POS tagging, NER, and dependency
parsing. It is particularly effective for processing legal texts due to its accuracy
and efficiency.
 NLTK (Natural Language Toolkit): A comprehensive library for text preprocessing
tasks such as stopword removal, stemming, and lemmatization.
 TensorFlow and PyTorch: Deep learning frameworks used for training and
deploying machine learning models. They provide flexibility and scalability for
handling large datasets and complex models.
 Scikit-learn: A machine learning library used for tasks such as data splitting,
evaluation, and hyperparameter tuning.
8. Datasets
 Legal Case Law Datasets: Collections of court judgments and case files annotated
with summaries, used for training and evaluating the summarization models.
 Contract Datasets: Datasets containing legal contracts and agreements, which
are used to train models for summarizing contractual terms and clauses.
 Publicly Available Legal Corpora: Resources such as the CaseLaw Access Project
(CAP) and the Indian Legal Judgment Corpus (ILJC), which provide large volumes
of legal texts for research purposes.

8
9. Evaluation Metrics
 ROUGE (Recall-Oriented Understudy for Gisting Evaluation): A set of metrics
used to evaluate the quality of summaries by comparing them to human-written
references. ROUGE measures overlap in terms of n-grams, word sequences, and
word pairs.
 BLEU (Bilingual Evaluation Understudy): A metric commonly used in machine
translation and summarization to assess the coherence and fluency of generated
text.
 METEOR: A metric that considers synonymy and word order, providing a more
nuanced evaluation of summary quality.
 Human Evaluation: Legal professionals review and rate the generated summaries
for accuracy, relevance, and readability, ensuring that the summaries meet
domain-specific standards.
10. Cloud Computing and Deployment
 Google Colab and Jupyter Notebooks: Used for prototyping and experimenting
with models in an interactive environment.
 AWS (Amazon Web Services) and Google Cloud Platform (GCP): Cloud platforms
used for training large models and deploying the summarization system at scale.
 Docker: A containerization tool used to package the application and its
dependencies for seamless deployment across different environments.
 Flask/Django: Web frameworks used to build a user-friendly interface for the
summarization system, allowing users to upload documents and receive
summaries.
11. Domain-Specific Tools
 Legal NLP Libraries: Specialized libraries such as LexNLP and LegalBERT, which are
designed to handle the unique characteristics of legal texts.

9
 Ontologies and Knowledge Graphs: Tools for representing legal concepts and
relationships, which can enhance the summarization process by providing
additional context.

10
 CHAPTER 3
PROJECT IMPLEMENTATION
1. Problem Definition
The goal of this project is to develop a system that can automatically detect and
classify emails as spam (unwanted emails) or ham (legitimate emails). The system uses
machine learning models and natural language processing (NLP) techniques to identify
the characteristics of spam messages.
2. Data Collection
 Dataset:
o The most commonly used dataset for this task is the SMS Spam Collection
Dataset or Enron Spam Dataset, which contains labeled examples of spam
and non-spam emails or messages.
o Each entry in the dataset has a label (e.g., spam or ham) and the message
content.
 Data Format:
o Typically, the dataset consists of two columns:
 Label: Indicates if the email is spam or ham.
 Message: The text content of the email or message.
3. Data Preprocessing
Data preprocessing is critical for transforming raw text into a format that can be
used by machine learning models.
 Text Cleaning:
o Remove unnecessary characters such as punctuation marks, special
characters, and numbers.
o Convert all text to lowercase to ensure consistency.
o Remove common stopwords (e.g., "and," "the," "is") that don’t provide
meaningful information for classification.

11
  Tokenization:
o Split the text into individual words or tokens. This helps the system
analyze the frequency of each word.
 Stemming or Lemmatization:
o Reduce words to their base forms (e.g., "running" becomes "run"). This
step helps reduce dimensionality and noise.
4. Feature Extraction
After cleaning the text, we need to convert the text data into numerical form so
machine learning algorithms can process it.
 Bag of Words (BoW):
o This method represents each email as a vector where each dimension
corresponds to a word in the entire corpus. The value in each dimension is
the frequency of that word in the email.
 TF-IDF (Term Frequency-Inverse Document Frequency):
o This technique evaluates the importance of a word within a document
relative to its frequency across all documents. Words that appear
frequently in one email but rarely across all emails are considered
important.
5. Model Selection
The next step is to choose a suitable machine learning model to classify the emails.
Common models for spam email detection include:
 Naive Bayes: A probabilistic classifier based on Bayes’ Theorem. It works well for
text classification tasks, especially when the features (words) are conditionally
independent.
 Support Vector Machine (SVM): A classifier that works by finding the hyperplane
that best separates the spam and ham emails in feature space.

12
  Logistic Regression: A linear model that can be used for binary classification
(spam vs. ham).
 Random Forest: An ensemble model that builds multiple decision trees and
aggregates their results.
 Deep Learning Models (Optional):
o Recurrent Neural Networks (RNNs) and Convolutional Neural Networks
(CNNs) can be used for more complex text-based classification tasks,
though they are not usually necessary for simple spam detection.
6. Model Training
The chosen model is trained using the preprocessed data. In this stage, the model learns
the patterns that distinguish spam from ham emails.
 Training the Model:
o Split the dataset into two parts: a training set (used to train the model)
and a test set (used to evaluate the model).
o During training, the model adjusts its parameters to minimize the error
(incorrect classifications) using optimization techniques like gradient
descent.
7. Model Evaluation
Once the model is trained, it needs to be evaluated to ensure its effectiveness.
 Accuracy: Measures the proportion of correct classifications (spam and ham) out
of all predictions.
 Confusion Matrix: A table that shows the true positives (spam correctly classified
as spam), false positives (ham incorrectly classified as spam), true negatives (ham
correctly classified as ham), and false negatives (spam incorrectly classified as
ham).
 Precision, Recall, and F1-Score:

13
 o Precision: The proportion of true positive spam emails out of all emails
classified as spam.
o Recall: The proportion of true positive spam emails out of all actual spam
emails.
o F1-Score: The harmonic mean of precision and recall, providing a balance
between the two.

8. Hyperparameter Tuning (Optional)

In this step, we adjust the hyperparameters of the chosen model to improve
performance. For example:
 Adjusting the alpha parameter in Naive Bayes to control smoothing.
 Tuning the C parameter in SVM to control the trade-off between bias and
variance.

9. Model Deployment
Once the model is trained and evaluated, it can be deployed to classify new emails.
 Real-Time Classification:
o The model can be integrated into an email client or server to classify
incoming emails in real time as spam or ham.
 Batch Classification:
o Alternatively, the system can process emails in batches and generate
reports or alerts for the user.
10. Model Updating: The model should be updated periodically with new labeled data
to maintain high performance as spammers evolve their tactics.

14
 CHAPTER 4
CODING
import pandas as pd
import random
importuuid
import re
import string
importnltk
fromnltk.corpus import stopwords
fromsklearn.feature_extraction.text import TfidfVectorizer
fromsklearn.model_selection import train_test_split
fromsklearn.linear_model import LogisticRegression
fromsklearn.metrics import accuracy_score, classification_report
nltk.download('stopwords')
file_path = "/content/email_spam_dataset.csv"
df = pd.read_csv(file_path)
defclean_text(text):
text = text.lower() # Convert to lowercase
text = re.sub(f"[{string.punctuation}]", "", text) # Remove punctuation
text = " ".join([word for word in text.split() if word not in
stopwords.words('english')]) # Remove stopwords
return text
df["clean_subject"] = df["subject"].apply(clean_text)
df["clean_body"] = df["body"].apply(clean_text)
df["text"] = df["clean_subject"] + " " + df["clean_body"]
vectorizer = TfidfVectorizer(max_features=5000)
X = vectorizer.fit_transform(df["text"])

15
y = df["spam"]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = LogisticRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)
print("Classification Report:\n", classification_report(y_test, y_pred))
print("Model training complete!")
defpredict_email(subject, body):
email_text = clean_text(subject) + " " + clean_text(body)
email_vector = vectorizer.transform([email_text])
prediction = model.predict(email_vector)[0]
result = "Spam" if prediction == 1 else "Not Spam"
print("\nEmail:")
print("Subject:", subject)
print("Body:", body)
print("Prediction:", result)
return result
sample_subject = "Win a free vacation now!"
sample_body = "Click the link to claim your reward today. Limited time offer!"
prediction_result = predict_email(sample_subject, sample_body)

CHAPTER 5
16
 TESTING AND OPTIMIZATION

Project testing can involve various types depending on the nature of the project
(e.g., software development, product design, or research). Here are some common
types of project testing:
1. Unit Testing
What it is: Testing individual components or units of a project (typically code).
Used for: Ensuring that each unit of the project functions as expected.
Example: Testing individual functions or methods in software development.
2. Integration Testing
What it is: Testing the interaction between different components or systems to
ensure they work together.
Used for: Ensuring that when multiple components are combined, they function as
expected.
Example: Testing how the frontend and backend communicate in a web application.
3. System Testing
What it is: Testing the complete and integrated system to verify if it meets the
specified requirements.
Used for: Ensuring that the overall system works as intended.
Example: Testing the full functionality of a software application.
4. Acceptance Testing
What it is: Testing to ensure the product meets the business requirements and is
ready for deployment.
Used for: Determining if the project is complete and ready for end users.
Example: User acceptance testing (UAT) where end-users verify the product.

17
5. Regression Testing
What it is: Testing after changes (e.g., code updates) to ensure that new code hasn't
broken existing functionality.
Used for: Ensuring new features or fixes don't affect the existing parts of the project.
Example: Re-running tests after fixing bugs in software to ensure old functionality
still works.
6. Performance Testing
What it is: Testing how the system performs under load.
Used for: Identifying performance bottlenecks and ensuring the system can handle
high volumes of traffic or data.
Example: Load testing a website to see how it performs with a high number of
concurrent users.
7. Security Testing
What it is: Testing for vulnerabilities and weaknesses in the system.
Used for: Ensuring that the project is secure and that sensitive data is protected.
Example: Penetration testing to find and fix security vulnerabilities in a software
product.
8. Usability Testing
What it is: Testing the product from an end-user perspective to ensure it is easy to
use and intuitive.
Used for: Ensuring that the product is user-friendly and provides a positive user
experience.
Example: Observing users interacting with a website and identifying usability issues.
9. Alpha Testing
What it is: Internal testing of the product to find bugs and issues before it’s released
to a select group of users.
Used for: Identifying major issues before releasing the product to beta testers.

18
 Example: Testing a new app internally within the company.
10. Beta Testing
What it is: Testing by a small group of external users before the product is officially
launched.
Used for: Getting feedback from real users in real-world environments.
Example: Allowing a group of users to test a new software version before the official
public release.
11. Stress Testing
What it is: Testing the system beyond normal operating conditions to determine its
breaking point.
Used for: Identifying how the system behaves under extreme stress or failure
conditions.
Example: Stress testing a website by simulating thousands of simultaneous users.
12. Smoke Testing
What it is: A preliminary test to check if the basic features of the project are
working.
Used for: Determining if the project is stable enough for further testing.
Example: Quickly checking if a web application loads without crashing.
13. Compatibility Testing
What it is: Testing how the system works across different platforms, devices,
browsers, or environments.
Used for: Ensuring the project functions well across various conditions and
configurations.
Example: Testing a website on multiple browsers (Chrome, Firefox, Safari).
14. Exploratory Testing
What it is: Testing without predefined test cases, often used for discovery or
uncovering unexpected issues.

19
 Used for: Investigating unknown areas of the project or testing edge cases.
Example: A tester exploring the app's interface to see if anything breaks.
15. A/B Testing
What it is: Comparing two versions of a product to determine which one performs
better with users.
Used for: Testing different versions to identify which one drives better results.
Example: Testing two variations of a website's landing page to see which version
increases user sign-ups.

20
 CHAPTER 6
SAMPLE OUTPUT

21
 CHAPTER 7
CONCLUSION

The implemented spam detection model successfully classifies emails as Spam or

Not Spam using Natural Language Processing (NLP) and Machine Learning. The key
takeaways from this project are:
1. Text Preprocessing:
o The model cleans the email text by removing punctuation, stopwords,
and converting text to lowercase, improving feature extraction.
2. Feature Engineering:
o The TF-IDF (Term Frequency-Inverse Document Frequency) technique is
used to convert text into numerical data for model training.
3. Model Performance:
o A Logistic Regression classifier is trained on the dataset, achieving an
acceptable accuracy based on classification metrics.
o Evaluation using accuracy score and classification report helps assess
precision, recall, and F1-score.
4. Real-time Predictions:
o The model is capable of predicting new emails in real-time and displaying
subject, body, and spam classification.
Possible Improvements:
 Use Deep Learning models (LSTMs, BERT) for better contextual understanding.
 Implement additional features like sender reputation, metadata, and embedded
URLs.
Improve dataset quality by including real-world spam and ham emails.

22
REFERENCES
1. Almeida, T. A., Hidalgo, J. M. G., &Yamakami, A. (2011). Contributions to the
study of SMS spam filtering - ACM Symposium on Document Engineering.
2. Guzella, T. S., &Caminhas, W. M. (2009). A review of machine learning
approaches to spam filtering - Expert Systems with Applications.
3. Ian Goodfellow, YoshuaBengio, Aaron Courville – Deep Learning (MIT Press)
4. Scikit-learn documentation on Text Feature Extraction
5. SMS Spam Collection: UCI Machine Learning Repository
6. TensorFlow's Text Classification with NLP
7. The Enron Email Dataset: Kaggle Enron Dataset
8. Towards Data Science: Spam Email Detection with Machine Learning

23