Spam Detection Workflow

python
"""
Spam vs. Ham Classification in Python
=====================================

This script demonstrates a simple workflow for classifying emails (or text messages) 
as spam or ham using both traditional machine learning (ML) models and a deep learning (DL) model.

Steps Covered:
1. Dataset Creation/Loading (sample dataset used here for illustration)
2. Data Preprocessing (cleaning, tokenization, stopword removal, vectorization)
3. Train-Test Split
4. Training Traditional ML Models (Logistic Regression, Naive Bayes, SVM)
5. Evaluating Traditional ML Models
6. Building and Training a Deep Learning Model (Optional)
7. Comparing and Analyzing Results
"""

# =====================================================
# Step 1: Dataset (For demonstration, we'll create a small sample dataset)
# =====================================================

import re
import string
import numpy as np

# Sample text data (X) and corresponding labels (y)
X = [
    "Congratulations! You've won a free gift card.",
    "Hi John, how was your day?",
    "Claim your FREE prize NOW!!!",
    "Meeting is scheduled at 10 AM tomorrow.",
    "Don't forget to submit your assignment.",
    "Exclusive offer! Get 50% off your next purchase.",
    "This is definitely not spam, it's just a normal message.",
    "URGENT: You have won a 1 week FREE membership!"
]
y = [
    "spam",  # "Congratulations! You've won a free gift card."
    "ham",   # "Hi John, how was your day?"
    "spam",  # "Claim your FREE prize NOW!!!"
    "ham",   # "Meeting is scheduled at 10 AM tomorrow."
    "ham",   # "Don't forget to submit your assignment."
    "spam",  # "Exclusive offer! Get 50% off your next purchase."
    "ham",   # "This is definitely not spam, it's just a normal message."
    "spam"   # "URGENT: You have won a 1 week FREE membership!"
]

# =====================================================
# Step 2: Data Preprocessing
#    - Text Cleaning
#    - Tokenization (can be done automatically by vectorizers)
#    - Stopword Removal
#    - Vectorization (We'll use TF-IDF here)
# =====================================================

import nltk
# If you haven't downloaded NLTK stopwords before, uncomment the line below:
# nltk.download('stopwords')
from nltk.corpus import stopwords
from sklearn.feature_extraction.text import TfidfVectorizer

stop_words = set(stopwords.words('english'))

def clean_text(text):
    # Lowercase
    text = text.lower()
    # Remove punctuation
    text = text.translate(str.maketrans('', '', string.punctuation))
    # Remove numbers
    text = re.sub(r'\d+', '', text)
    # Remove extra whitespace
    text = text.strip()
    return text

cleaned_X = [clean_text(doc) for doc in X]

# TF-IDF Vectorizer with English stopwords
vectorizer = TfidfVectorizer(stop_words=stop_words)
X_tfidf = vectorizer.fit_transform(cleaned_X)

# =====================================================
# Step 3: Train-Test Split (80%-20%)
# =====================================================
from sklearn.model_selection import train_test_split

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

# =====================================================
# Step 4: Train Machine Learning Models
#    - Logistic Regression
#    - Naive Bayes
#    - SVM
# =====================================================
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import MultinomialNB
from sklearn.svm import SVC

# Logistic Regression
logreg = LogisticRegression()
logreg.fit(X_train, y_train)

# Naive Bayes
nb = MultinomialNB()
nb.fit(X_train, y_train)

# SVM
svm = SVC(kernel='linear', probability=True)
svm.fit(X_train, y_train)

# =====================================================
# Step 5: Evaluate Models
#    - Metrics: accuracy, precision, recall, F1-score, confusion matrix
# =====================================================
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, classification_report

def evaluate_model(model, X_test, y_test):
    y_pred = model.predict(X_test)
    print(f"Model: {model.__class__.__name__}")
    print("Accuracy:", accuracy_score(y_test, y_pred))
    print("Precision:", precision_score(y_test, y_pred, pos_label='spam'))
    print("Recall:", recall_score(y_test, y_pred, pos_label='spam'))
    print("F1-score:", f1_score(y_test, y_pred, pos_label='spam'))
    print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))
    print("Classification Report:\n", classification_report(y_test, y_pred), "\n")

# Evaluate each model
evaluate_model(logreg, X_test, y_test)
evaluate_model(nb, X_test, y_test)
evaluate_model(svm, X_test, y_test)

# =====================================================
# Step 6: Deep Learning for Spam Detection (Optional)
#    - We'll build a simple LSTM model in TensorFlow/Keras
# =====================================================
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense, Dropout

# (a) Prepare text sequences for Keras
#     We need to do a separate tokenization (Keras-based) for the DL approach

# Clean texts again (for demonstration, we already cleaned above, but let's ensure steps)
raw_texts = [clean_text(doc) for doc in X]

# Keras Tokenizer
tokenizer = Tokenizer(num_words=1000, oov_token='<OOV>')
tokenizer.fit_on_texts(raw_texts)
sequences = tokenizer.texts_to_sequences(raw_texts)

# Pad sequences
max_length = max(len(seq) for seq in sequences)
padded_sequences = pad_sequences(sequences, maxlen=max_length, padding='post')

# Convert labels "spam"/"ham" to binary (1 for spam, 0 for ham)
label_map = {"spam":1, "ham":0}
binary_labels = np.array([label_map[label] for label in y])

# Train-Test Split (80-20) for deep learning data
X_train_dl, X_test_dl, y_train_dl, y_test_dl = train_test_split(
    padded_sequences, 
    binary_labels, 
    test_size=0.2, 
    random_state=42
)

# (b) Build a simple LSTM model
vocab_size = 1000  # Must match tokenizer num_words
embedding_dim = 16

model = Sequential()
model.add(Embedding(input_dim=vocab_size, 
                    output_dim=embedding_dim, 
                    input_length=max_length))
model.add(LSTM(16, return_sequences=False))
model.add(Dropout(0.3))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
model.summary()

# (c) Train the model
model.fit(X_train_dl, y_train_dl, epochs=5, validation_split=0.2, verbose=1)

# (d) Evaluate the model
loss, accuracy = model.evaluate(X_test_dl, y_test_dl, verbose=0)
print("Deep Learning Model Evaluation:")
print(f"Test Loss: {loss:.4f}")
print(f"Test Accuracy: {accuracy:.4f}")

# Additional metrics for DL model predictions
y_pred_dl = (model.predict(X_test_dl) > 0.5).astype("int32")
print("Precision:", precision_score(y_test_dl, y_pred_dl, pos_label=1))
print("Recall:", recall_score(y_test_dl, y_pred_dl, pos_label=1))
print("F1-score:", f1_score(y_test_dl, y_pred_dl, pos_label=1))
print("Confusion Matrix:\n", confusion_matrix(y_test_dl, y_pred_dl))
print("Classification Report:\n", classification_report(y_test_dl, y_pred_dl))

# =====================================================
# Step 7: Compare and Analyze Results
# =====================================================
"""
In a real scenario, you would:
- Compare accuracy, precision, recall, and F1-score of each model (Logistic Regression, Naive Bayes, SVM, and the LSTM).
- Look at misclassified examples to see patterns (e.g., certain words that might be misleading).
- Potentially improve preprocessing, tuning hyperparameters, or gathering more data to improve performance.

Note:
- This example uses a very small dataset just for demonstration purposes, so the results 
  are not necessarily representative of real-world performance.
- For real spam detection tasks, use a larger and more comprehensive dataset such as the 
  "SMS Spam Collection Dataset" or email-based spam corpora.
"""

Explanation of Key Sections:

1. Data Creation/Loading: We created a small sample dataset in-place.
2. Preprocessing: Lowercasing, removing punctuation/numbers, and using TF-IDF for ML models. For the deep learning model, we used a Keras Tokenizer and padded the sequences.
3. Train-Test Split: We used an 80-20 split for both the ML and DL pipelines.
4. Traditional ML Models: Demonstrated training LogisticRegression, MultinomialNB, and SVC.
5. Evaluation: Printed out accuracy, precision, recall, F1-score, and confusion matrix.
6. Deep Learning Model: Built a simple LSTM-based model in TensorFlow/Keras with an Embedding layer.
7. Comparison: In practice, compare the metrics of both approaches to choose the most effective model.

python
"""
Hugging Face Models Exploration, Application, and NER Fine-tuning
=================================================================

This short script demonstrates:
1. How to explore available Hugging Face models for NLP tasks.
2. How to select a dataset from Hugging Face and apply a pre-trained model.
3. How to evaluate model performance with common metrics (Accuracy, Precision, Recall, F1, BLEU, ROUGE).
4. How to fine-tune a pre-trained NER model and compare its performance to the base model.

Prerequisites:
    pip install transformers datasets evaluate huggingface_hub

Note: This example uses very small subsets and simplified steps for brevity. 
In practice, more comprehensive data preparation and hyperparameter tuning are recommended.
"""

# ==========================
# Step 1: Explore Available Models
# ==========================
from huggingface_hub import list_models

# List first 5 models on Hugging Face
available_models = list_models(limit=5)
print("Some available models on Hugging Face:")
for model_info in available_models:
    print(" -", model_info.modelId)

# ==========================
# Step 2: Apply a Pre-trained Model to a Dataset
# (Example: Sentiment Classification on IMDb)
# ==========================
from datasets import load_dataset
from transformers import pipeline
import numpy as np

# Load a small subset of the IMDb dataset for demo
imdb = load_dataset("imdb", split="test[:20]")  # only first 20 samples for speed

# Use a DistilBERT sentiment classification model
classifier = pipeline("text-classification", 
                      model="distilbert-base-uncased-finetuned-sst-2-english")

# Get predictions
predictions = classifier(imdb["text"])

# Prepare labels and preds for metric calculation
true_labels = [1 if label == "pos" else 0 for label in imdb["label"]]
pred_labels = [1 if pred["label"] == "POSITIVE" else 0 for pred in predictions]

# Evaluate using Accuracy, Precision, Recall, F1
import evaluate
accuracy_metric = evaluate.load("accuracy")
precision_metric = evaluate.load("precision")
recall_metric = evaluate.load("recall")
f1_metric = evaluate.load("f1")

acc = accuracy_metric.compute(references=true_labels, predictions=pred_labels)
prec = precision_metric.compute(references=true_labels, predictions=pred_labels, average="binary")
rec = recall_metric.compute(references=true_labels, predictions=pred_labels, average="binary")
f1 = f1_metric.compute(references=true_labels, predictions=pred_labels, average="binary")

print("\nSentiment Classification Metrics (DistilBERT on IMDb subset):")
print("Accuracy:", acc["accuracy"])
print("Precision:", prec["precision"])
print("Recall:", rec["recall"])
print("F1-score:", f1["f1"])

# ==========================
# (Optional) For other tasks like:
#  - Machine Translation: use BLEU
#  - Summarization: use ROUGE
# Example usage:
# bleu = evaluate.load("bleu")
# rouge = evaluate.load("rouge")
# ==========================


# ==========================
# Step 3: Fine-tune a Pre-trained NER Model & Compare Performance
# (Example: BERT fine-tuned on CoNLL-2003)
# ==========================
from transformers import (AutoTokenizer, AutoModelForTokenClassification, 
                          TrainingArguments, Trainer, DataCollatorForTokenClassification)

# Load a pre-trained Token Classification model and tokenizer
model_name = "bert-base-cased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForTokenClassification.from_pretrained(model_name, num_labels=9)  # CoNLL-2003 has 9 entity labels

# Load a small subset of the conll2003 dataset
conll = load_dataset("conll2003", split="train[:50]")  # only 50 samples for demo

# Tokenize and align labels for NER
def tokenize_and_align_labels(examples):
    tokenized_inputs = tokenizer(examples["tokens"], truncation=True, is_split_into_words=True)
    labels = []
    for i, label in enumerate(examples["ner_tags"]):
        word_ids = tokenized_inputs.word_ids(batch_index=i)
        label_ids = []
        previous_word_id = None
        for word_id in word_ids:
            if word_id is None:
                label_ids.append(-100)
            elif word_id != previous_word_id:
                label_ids.append(label[word_id])
            else:
                label_ids.append(-100)
            previous_word_id = word_id
        labels.append(label_ids)
    tokenized_inputs["labels"] = labels
    return tokenized_inputs

tokenized_conll = conll.map(tokenize_and_align_labels, batched=True)
data_collator = DataCollatorForTokenClassification(tokenizer)

# Split a small train/test for demonstration
small_train = tokenized_conll.select(range(30))
small_test = tokenized_conll.select(range(30, 50))

# Load evaluation metric (seqeval for NER)
seqeval = evaluate.load("seqeval")

def compute_metrics(eval_preds):
    logits, labels = eval_preds
    predictions = np.argmax(logits, axis=-1)
    true_labels = []
    pred_labels = []
    for p, l in zip(predictions, labels):
        true_l = []
        pred_l = []
        for pi, li in zip(p, l):
            if li != -100:
                true_l.append(li)
                pred_l.append(pi)
        true_labels.append(true_l)
        pred_labels.append(pred_l)
    return seqeval.compute(predictions=[pred_labels], references=[true_labels])

# Training setup
training_args = TrainingArguments(
    output_dir="./ner-finetune-demo",
    evaluation_strategy="steps",
    per_device_train_batch_size=2,
    per_device_eval_batch_size=2,
    num_train_epochs=1,
    logging_steps=5,
    eval_steps=5
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=small_train,
    eval_dataset=small_test,
    data_collator=data_collator,
    tokenizer=tokenizer,
    compute_metrics=compute_metrics
)

# Fine-tune the model (quick demo)
trainer.train()

# Evaluate the fine-tuned model
eval_results = trainer.evaluate()
print("\nFine-tuned NER Model Evaluation on small test set:")
print(eval_results)

"""
Compare these new metrics with the base (pre-fine-tuned) model's performance on the same data.
In a real scenario, you'd run inference with the pre-trained (unfined-tuned) model and compute
the same metrics to see improvements in entity recognition.
"""

Explanation of Key Steps:

1. Exploring Models: Demonstrates how to list models on Hugging Face.
2. Applying a Model: Loads the IMDb dataset and applies a sentiment classifier, then computes Accuracy, Precision, Recall, and F1.
3. Fine-tuning an NER Model: Shows how to load a pre-trained BERT model, tokenize the CoNLL-2003 dataset for NER, and then fine-tune it using the Trainer API. We evaluate using the seqeval metric and compare the results before and after fine-tuning.

For other NLP tasks (Text Generation, Summarization, Machine Translation, etc.), you would follow a similar pattern with the relevant pipeline/model and metrics (BLEU for translation, ROUGE for summarization, etc.).

Here’s why the error occurs and how to fix it:

Why does this error happen?
Most Transformer-based models (including DistilBERT) have a maximum sequence length (often 512 tokens). If an input text is longer, you may see a “Size of tensor a (XXX) must match … (512)” error. In other words, the model can’t handle the extra tokens without explicit truncation.

How to fix it:
When using a pipeline (e.g., pipeline("text-classification")), simply enable truncation and optionally padding. This tells the tokenizer to cut off any tokens beyond the maximum length rather than trying to pass them through to the model.

Below is a short example showing how to do this with the IMDb dataset. Notice the added parameters: padding=True, truncation=True, max_length=512.

python
from datasets import load_dataset
from transformers import pipeline
import evaluate

# 1. Load a small subset of IMDb
imdb = load_dataset("imdb", split="test[:20]")  # first 20 samples for brevity

# 2. Create a text-classification pipeline with truncation
classifier = pipeline(
    "text-classification",
    model="distilbert-base-uncased-finetuned-sst-2-english",
    tokenizer="distilbert-base-uncased-finetuned-sst-2-english",
    padding=True,        # pad to max length
    truncation=True,     # truncate inputs longer than max_length
    max_length=512       # DistilBERT's typical max length
)

# 3. Run predictions on text data
predictions = classifier(imdb["text"])

# 4. Convert pipeline outputs to binary labels and evaluate
true_labels = [1 if label == "pos" else 0 for label in imdb["label"]]
pred_labels = [1 if pred["label"] == "POSITIVE" else 0 for pred in predictions]

accuracy = evaluate.load("accuracy")
precision = evaluate.load("precision")
recall = evaluate.load("recall")
f1 = evaluate.load("f1")

acc = accuracy.compute(references=true_labels, predictions=pred_labels)
prec = precision.compute(references=true_labels, predictions=pred_labels, average="binary")
rec_ = recall.compute(references=true_labels, predictions=pred_labels, average="binary")
f1_ = f1.compute(references=true_labels, predictions=pred_labels, average="binary")

print("Accuracy:", acc["accuracy"])
print("Precision:", prec["precision"])
print("Recall:", rec_["recall"])
print("F1-score:", f1_["f1"])

Additional Notes

1. Chunking Long Documents
   For very long texts (like full IMDB reviews), even truncation at 512 tokens can cause information loss. If high accuracy is needed on long documents, consider:

   • Splitting text into smaller chunks (e.g., 256 or 512 tokens each) and then aggregating predictions.
   • Using models designed for longer context windows (e.g., Longformer, BigBird, etc.).

2. Memory / GPU Issues
   If you run into out-of-memory (OOM) errors, try reducing batch size or running on CPU. You can also set device=0 (if you have a GPU) or device=-1 (CPU only) in the pipeline call:

   python
   classifier = pipeline("text-classification", model="...", device=-1)  # CPU

   or

   python
   classifier = pipeline("text-classification", model="...", device=0)   # GPU

By specifying padding=True, truncation=True, max_length=512, you ensure that each input is correctly sized for the model, preventing the dimension mismatch error.