Training a TensorFlow Model to Detect Spam and Phishing Emails from Real-World Text Data

Table of Contents#

1. Why Deep Learning Outperforms Legacy Spam Filters
2. Prerequisites for This Tutorial
3. Top Datasets for Real-World Spam/Phishing Training
4. End-to-End NLP Preprocessing Pipeline
5. Best TensorFlow Model Architectures for Email Classification
6. Step-by-Step TensorFlow Implementation Walkthrough
7. Model Evaluation Metrics for Imbalanced Text Data
8. Common Pitfalls to Avoid
9. 2026 Latest Developments in Spam Detection
10. Conclusion
11. References

Why Deep Learning Outperforms Legacy Spam Filters#

Spam and phishing detection is a binary text classification problem: given raw email text, the model labels it as either malicious (spam/phishing) or legitimate (ham). Legacy rule-based systems fail because:

• Attackers easily bypass keyword filters by misspelling words (e.g., "Fr33 B1tc0in") or using context-dependent lures
• Rules require constant manual updates to block new attack vectors
• They generate high rates of false positives, sending legitimate emails to spam folders

Deep learning models solve these issues by learning semantic and sequential patterns from thousands of real email samples. They are already used in production by providers like Google (which uses Gemini for Gmail spam filtering as of 2025) and enterprise security firms.

Real-World Use Cases#

• Enterprise email security tools blocking targeted spear phishing attacks
• Consumer email providers reducing false positive rates
• Collaboration platforms (Slack, Microsoft Teams) filtering malicious links in messages
• Fintech platforms verifying the legitimacy of customer support emails

Prerequisites for This Tutorial#

To follow along, you will need:

• Basic proficiency in Python and machine learning fundamentals
• Familiarity with TensorFlow/Keras 2.15+
• Required packages installed:

  pip install tensorflow nltk pandas numpy scikit-learn matplotlib

• Basic understanding of NLP concepts like tokenization and embeddings

Top Datasets for Real-World Spam/Phishing Training#

The quality of your training data directly impacts model performance. Use these curated, widely accepted datasets for benchmarking and production training:

Best Practice: Combine 2-3 datasets for production training to ensure your model generalizes across different email types and attack vectors.

End-to-End NLP Preprocessing Pipeline#

Preprocessing accounts for ~70% of model performance for text classification tasks. Follow this standardized pipeline to clean and prepare raw email data:

Step 1: Text Cleaning#

Remove noisy, non-content data from raw emails:

• Strip email headers (e.g., Subject:, From:) and metadata
• Remove HTML tags, URLs, and special characters
• Filter out non-ASCII text to remove obfuscated characters

Step 2: Normalization#

• Convert all text to lowercase to avoid treating "Free" and "free" as separate tokens
• Remove punctuation and common stopwords (e.g., "the", "and", "a") using NLTK
• Use either stemming (PorterStemmer) for fast prototyping or lemmatization (WordNetLemmatizer) for more accurate semantic mapping of words

Step 3: Sequence Preparation#

• Tokenization: Convert cleaned text into sequences of integers using tf.keras.preprocessing.text.Tokenizer
• Padding: Standardize sequence length to a fixed value using tf.keras.preprocessing.sequence.pad_sequences (truncate long sequences, pad short ones with zeros)
• Dataset Balancing: Spam/phishing samples are usually the minority class (10-30% of total data). Downsample the majority ham class or upsample the minority spam class to avoid bias toward the majority class.

Sample Preprocessing Code Snippet#

import nltk
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
import re
 
nltk.download('stopwords')
nltk.download('wordnet')
stop_words = set(stopwords.words('english'))
lemmatizer = WordNetLemmatizer()
 
def clean_email(text):
    # Remove headers, URLs, special chars
    text = re.sub(r'^Subject:.*?\n', '', text, flags=re.MULTILINE)
    text = re.sub(r'https?://\S+|www\.\S+', '', text)
    text = re.sub(r'[^a-zA-Z0-9\s]', '', text)
    # Lowercase and remove stopwords
    text = text.lower()
    text = ' '.join([word for word in text.split() if word not in stop_words])
    # Lemmatize
    text = ' '.join([lemmatizer.lemmatize(word) for word in text.split()])
    return text

Best TensorFlow Model Architectures for Email Classification#

Choose an architecture based on your use case, computational resources, and performance requirements:

1. Simple DNN with Embedding Layer (Baseline)#

Structure: TextVectorization → Embedding → GlobalAveragePooling1D → Dense layers Use Case: Fast baseline model, low-resource environments Pros: Fast to train, low inference latency Cons: Less effective at capturing sequential context

2. CNN for Text Classification#

Structure: Embedding → Conv1D + MaxPooling → Dense layers Use Case: Detecting local n-gram patterns (e.g., "free gift card", "verify your bank account") Pros: Extremely fast, good at identifying common spam phrases Cons: Poor at capturing long-range context in sophisticated phishing lures

3. Bidirectional LSTM#

Structure: Embedding → Bidirectional(LSTM) → Dense layers Use Case: Detecting context-dependent phishing attacks Pros: Captures sequential context across the entire email text Cons: Slower to train than CNN/DNN

4. Hybrid LSTM-GRU (Recommended for Most Use Cases)#

Structure: Embedding → Bidirectional(LSTM) → GRU → Dropout → Dense layers Use Case: Production-grade models balancing accuracy and speed Pros: 2025 MDPI research shows this hybrid architecture outperforms individual RNN variants, achieving 97%+ F1-score on standard datasets, with 30% faster training than pure LSTM models

5. BERT/Transformer-Based Models#

Structure: Fine-tuned pre-trained BERT/DistilBERT → Classification head Use Case: High-security environments where maximum accuracy is required Pros: Near-human performance on phishing detection, captures nuanced semantic context Cons: Requires more GPU resources, higher inference latency

Step-by-Step TensorFlow Implementation Walkthrough#

We will build a hybrid LSTM-GRU model, the best balance of performance and speed for most production use cases.

Step 1: Load and Split Data#

We use a 70/15/15 train/validation/test split to avoid overfitting:

import pandas as pd
from sklearn.model_selection import train_test_split
 
# Load combined dataset (Enron + SpamAssassin + PhishTank)
df = pd.read_csv('combined_spam_phish_dataset.csv')
df['cleaned_text'] = df['email_text'].apply(clean_email)
 
# Split data
X_train, X_temp, y_train, y_temp = train_test_split(df['cleaned_text'], df['label'], test_size=0.3, random_state=42)
X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=42)

Step 2: Tokenize and Pad Sequences#

Use standard hyperparameter ranges from industry best practices:

• Vocab size: 10,000-50,000
• Max sequence length: 100-500
• Embedding dimension: 64-128

import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
 
vocab_size = 20000
max_len = 300
embedding_dim = 128
 
# Fit tokenizer ONLY on training data to avoid data leakage
tokenizer = Tokenizer(num_words=vocab_size, oov_token="<OOV>")
tokenizer.fit_on_texts(X_train)
 
# Convert text to sequences
train_sequences = tokenizer.texts_to_sequences(X_train)
val_sequences = tokenizer.texts_to_sequences(X_val)
test_sequences = tokenizer.texts_to_sequences(X_test)
 
# Pad sequences
train_padded = pad_sequences(train_sequences, maxlen=max_len, padding='post', truncating='post')
val_padded = pad_sequences(val_sequences, maxlen=max_len, padding='post', truncating='post')
test_padded = pad_sequences(test_sequences, maxlen=max_len, padding='post', truncating='post')

Step 3: Build and Compile Model#

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(vocab_size, embedding_dim, input_length=max_len),
    tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64, return_sequences=True)),
    tf.keras.layers.GRU(32),
    tf.keras.layers.Dropout(0.3), # Regularization to prevent overfitting
    tf.keras.layers.Dense(32, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid')
])
 
# Compile with relevant metrics for imbalanced data
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy', tf.keras.metrics.Precision(name='precision'), tf.keras.metrics.Recall(name='recall')]
)
 
model.summary()

Step 4: Train Model with Callbacks#

Use early stopping to prevent overfitting and reduce learning rate on plateau:

early_stop = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True)
reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=2, min_lr=1e-6)
 
history = model.fit(
    train_padded, y_train,
    validation_data=(val_padded, y_val),
    epochs=20,
    batch_size=64,
    callbacks=[early_stop, reduce_lr]
)

Step 5: Predict on New Emails#

def predict_email(email_text):
    cleaned = clean_email(email_text)
    sequence = tokenizer.texts_to_sequences([cleaned])
    padded = pad_sequences(sequence, maxlen=max_len, padding='post', truncating='post')
    prediction = model.predict(padded)[0][0]
    return "Malicious (Spam/Phishing)" if prediction > 0.5 else "Legitimate (Ham)"
 
# Test with sample phishing email
sample_phish = "URGENT: Your bank account has been locked. Click here to verify your credentials: https://fake-bank-verification.com"
print(predict_email(sample_phish)) # Output: Malicious (Spam/Phishing)

Model Evaluation Metrics for Imbalanced Text Data#

Spam datasets are almost always imbalanced, so accuracy alone is a misleading metric. Use these metrics to evaluate real performance:

1. Precision: Percentage of predicted malicious emails that are actually malicious. Critical for avoiding false positives (sending legitimate emails to spam).
2. Recall: Percentage of actual malicious emails that are correctly detected. Critical for high-security environments to avoid missing phishing attacks.
3. F1-Score: Harmonic mean of precision and recall, the best single metric for imbalanced text classification.
4. AUC-ROC Curve: Measures the model's ability to distinguish between malicious and legitimate classes across all threshold values.
5. Confusion Matrix: Visualize true positives, false positives, true negatives, and false negatives to identify model gaps.

Production Tip: Adjust the classification threshold based on your use case. For consumer email, use a higher threshold (e.g., 0.7) to reduce false positives. For enterprise security, use a lower threshold (e.g., 0.3) to catch as many phishing attacks as possible, with secondary human review for borderline cases.

Common Pitfalls to Avoid#

1. Data Leakage: Never fit your tokenizer or preprocessing layers on the test/validation split. This causes inflated performance metrics that don't hold up in production.
2. Ignoring Class Imbalance: A model that predicts all emails as legitimate will achieve 90% accuracy on a dataset with 10% spam, but is completely useless. Always balance your dataset before training.
3. Overfitting on Small Datasets: Use dropout, early stopping, and data augmentation (synthetic spam text generation with LLMs) to reduce overfitting if you have limited training data.
4. Poor Preprocessing: Leaving HTML tags, headers, or special characters in training data introduces noise that reduces model performance.
5. Not Tuning Hyperparameters: Test different values for vocab size, max sequence length, embedding dimension, and batch size to optimize performance for your specific dataset.

2026 Latest Developments in Spam Detection#

• LLM Integration: Google uses Gemini for Gmail spam filtering, which reduces false positives by 38% compared to older RNN models. Fine-tuning small open-source LLMs like Llama 3 on phishing datasets delivers 8-10% higher F1-scores than traditional RNN models.
• Hybrid Approaches: Combining traditional ML models (Naive Bayes, SVM) with deep learning models delivers faster inference and better performance on edge devices.
• Transfer Learning: Pre-trained LLM embeddings can be used to train high-performance models with as little as 1,000 labeled email samples, a game-changer for small teams with limited data.
• Zero-Day Phishing Detection: Models fine-tuned on real-time threat data from PhishTank and other community sources can detect new zero-day phishing attacks within 24 hours of their first appearance.

Conclusion#

1. Preprocessing is the most important step for text classification: spend time cleaning and balancing your dataset to maximize model performance.
2. Choose the right architecture for your use case: use a simple DNN for baseline testing, a hybrid LSTM-GRU for production balance, and BERT/LLM fine-tuning for maximum accuracy.
3. Always use precision, recall, and F1-score to evaluate imbalanced spam datasets, not just accuracy.
4. Avoid common pitfalls like data leakage and class imbalance to ensure your model works as expected in production.
5. Leverage 2026 advances like LLM transfer learning to build high-performance models even with limited labeled data.

References#

1. GeeksforGeeks. (2025). Detecting Spam Emails Using Tensorflow in Python. https://www.geeksforgeeks.org/nlp/detecting-spam-emails-using-tensorflow-in-python/
2. TensorFlow Official Documentation. Basic Text Classification. https://www.tensorflow.org/tutorials/keras/text_classification
3. ResearchGate. (2023). Spam Detection Model Using TensorFlow and Deep Learning Algorithm. https://www.researchgate.net/publication/375120093
4. MDPI Applied Sciences. (2025). Spam Email Detection Using Long Short-Term Memory and Gated Recurrent Unit. https://www.mdpi.com/2076-3417/15/13/7407
5. Wiley. (2025). Leveraging Large Language Model on Spam Email Detection. https://onlinelibrary.wiley.com/doi/full/10.1155/acis/7032960
6. UCI Machine Learning Repository. Spambase Dataset. https://archive.ics.uci.edu/ml/datasets/spambase
7. Kaggle. Phishing Email Dataset. https://www.kaggle.com/datasets/naserabdullahalam/phishing-email-dataset
8. Apache SpamAssassin. Public Corpus. https://spamassassin.apache.org/old/publiccorpus/