ML Notes
HubAI vs ML vs Deep Learning — Machine LearningApplications of Machine LearningHistory of Machine LearningMachine Learning RoadmapWhat is Machine Learning?Calculus for Machine LearningData Preprocessing BasicsLinear Algebra for Machine LearningProbability Basics for Machine LearningPython for Machine LearningStatistics Basics for Machine LearningBias vs Variance TradeoffModel Evaluation OverviewOverfitting and UnderfittingReinforcement Learning Fundamentals — Machine LearningSupervised LearningTraining vs Testing DataTypes of Machine LearningUnsupervised LearningData Cleaning — Machine LearningData Collection for Machine LearningData Visualization for MLEncoding Categorical DataFeature EngineeringFeature ScalingHandling Missing ValuesTrain-Test SplitElastic Net RegressionLasso Regression (L1 Regularization)Multiple Linear RegressionPolynomial RegressionIntroduction to RegressionRegression ProjectsRidge Regression (L2 Regularization)Simple Linear RegressionIntroduction to ClassificationClassification ProjectsDecision TreesK-Nearest Neighbors (KNN)Logistic RegressionNaive Bayes ClassifierRandom Forest ClassificationSupport Vector Machine (SVM)XGBoost for ClassificationClustering in Machine Learning: Complete Guide to Unsupervised LearningClustering Projects: Real-World Applications and Implementation GuidesDBSCAN ClusteringGaussian Mixture Models (GMM): Probabilistic Clustering for Advanced Data AnalysisHierarchical ClusteringK-Means ClusteringDimensionality Reduction: Comprehensive Guide to Feature Reduction TechniquesFeature Selection Techniques: Choosing Informative Variables for ML ModelsLinear Discriminant Analysis (LDA): Supervised Dimensionality ReductionPrincipal Component Analysis (PCA)t-SNE: Non-Linear Dimensionality Reduction for Data VisualizationUMAP: Uniform Manifold Approximation and Projection for Modern Data VisualizationAdaBoost: Adaptive Boosting Algorithm Explained with ExamplesBagging: Bootstrap Aggregating for Reducing Model VarianceBoosting: Sequential Ensemble Learning for Bias and Variance ReductionEnsemble Learning: Complete Guide to Combining ML Models for Better PredictionsGradient Boosting: Building Powerful ML Models Through Sequential OptimizationRandom Forest: Complete Guide to Tree Ensembles and Feature ImportanceStacking: Advanced Ensemble Method Using Meta-Learners for Superior ML PredictionsActivation Functions in Neural NetworksBackpropagation: Complete Algorithm for Training Neural NetworksIntroduction to Deep Learning: Neural Networks, Architectures, and ApplicationsDeep Learning Projects: Hands-On Applications and Case StudiesNeural Networks Basics: Perceptron, Architecture, and TrainingPerceptron: Foundational Single-Neuron Classifier for Binary ClassificationPyTorch Basics: Building and Training Neural NetworksTensorFlow Basics: Building and Training Neural NetworksIntroduction to Natural Language Processing: Fundamentals and ApplicationsNLP Projects: Practical Applications from Sentiment Analysis to Machine TranslationStemming and Lemmatization: Reducing Words to Root Forms in NLPText Preprocessing: Essential Steps for NLP ApplicationsTF-IDF: Term Frequency-Inverse Document Frequency for Text Feature ExtractionTokenization in NLP: Breaking Text into Meaningful UnitsTransformers: The Architecture Behind Modern NLP ModelsWord Embeddings: Representing Words as Vectors for NLPIntroduction to Computer VisionComputer Vision ProjectsImage Classification: Building and Deploying CNN ModelsImage Processing BasicsImage Segmentation — Machine LearningObject DetectionOpenCV BasicsAgents and Environments in RLDeep Q-Networks (DQN)Policy Gradient Methods — Machine LearningQ-Learning AlgorithmReinforcement Learning: IntroductionReinforcement Learning ProjectsAccuracy, Precision, Recall: Classification Metrics Explained for ML InterviewConfusion Matrix: Complete Guide to Classification EvaluationCross-Validation: Comprehensive Guide to Robust Model EvaluationF1 Score: Balanced Classification Metric for Imbalanced DataGrid Search: Complete Guide to Hyperparameter Tuning in Machine LearningHyperparameter Tuning: Complete Guide to Optimizing Machine Learning ModelsModel Selection: Choosing the Best Algorithm for Your ML ProblemROC and AUC: Complete Guide to Classification Threshold EvaluationBuild an AI Assistant with LLMsBuild a Conversational ChatbotCustomer Churn PredictionFace Recognition System — Machine LearningHouse Price PredictionRecommendation System ProjectSentiment Analysis Project — Machine LearningSpam Email ClassifierML Case Study Questions for InterviewsML Coding Questions for Technical InterviewsMachine Learning Interview CheatsheetEssential Machine Learning Interview QuestionsStatistics for Machine Learning InterviewsDatasets for ML PracticeImportant ML FormulasMachine Learning GlossaryRecommended ML Books and CoursesCI/CD for Machine LearningDocker for Machine LearningFastAPI for Machine Learning APIsFlask API for Machine LearningMLOps: IntroductionModel Deployment StrategiesML Model Monitoring & Observability
Build a spam email classifier using text classification techniques and email features.
Build a classifier to identify spam emails with high precision and recall.
Problem Overview
Objective: Classify emails as spam or ham with 99%+ precision (minimize false positives)
Dataset: 5,572 emails labeled as spam/ham
Challenge: Balance catching spam vs not blocking legitimate emails
Key Features
Email Features
Text-based:
- Subject line content
- Email body words
- Sender address patterns
- Presence of URLs
Metadata:
- Sender reputation
- Email headers
- SPF/DKIM/DMARC records
- Domain age
Solution Pipeline
Step 1: Load and Explore Data
Example
import pandas as pd
import numpy as np
# Load data
emails = pd.read_csv('spam_emails.csv')
print(f"Total emails: {len(emails)}")
print(f"Spam: {(emails['label'] == 'spam').sum()}")
print(f"Ham: {(emails['label'] == 'ham').sum()}")
# Spam ratio
spam_ratio = (emails['label'] == 'spam').mean()
print(f"\nSpam ratio: {spam_ratio:.1%}")
# Check sample emails
print("\nSpam sample:")
print(emails[emails['label'] == 'spam']['text'].iloc[0][:200])
print("\nHam sample:")
print(emails[emails['label'] == 'ham']['text'].iloc[0][:200])
Step 2: Feature Engineering
Example
import re
from collections import Counter
def extract_features(email_text, email_subject=''):
features = {}
# Count features
features['num_words'] = len(email_text.split())
features['num_chars'] = len(email_text)
features['num_urls'] = len(re.findall(r'http\S+', email_text))
features['num_emails'] = len(re.findall(r'\S+@\S+', email_text))
features['num_exclamation'] = email_text.count('!')
features['num_caps'] = sum(1 for c in email_text if c.isupper())
# Content features
features['has_unsubscribe'] = 1 if 'unsubscribe' in email_text.lower() else 0
features['has_urgent'] = 1 if 'urgent' in email_text.lower() else 0
features['has_free'] = 1 if 'free' in email_text.lower() else 0
features['has_click_here'] = 1 if 'click here' in email_text.lower() else 0
# Subject line features
features['subject_has_urgent'] = 1 if 'urgent' in email_subject.lower() else 0
features['subject_has_free'] = 1 if 'free' in email_subject.lower() else 0
features['subject_has_verify'] = 1 if 'verify' in email_subject.lower() else 0
return features
# Extract features for all emails
feature_list = []
for idx, row in emails.iterrows():
features = extract_features(row['text'], row.get('subject', ''))
feature_list.append(features)
features_df = pd.DataFrame(feature_list)
X = pd.concat([features_df, emails[['text']]], axis=1)
y = (emails['label'] == 'spam').astype(int)
print(f"Features extracted: {X.shape[1]} features")
Step 3: Text Features with TF-IDF
Example
from sklearn.feature_extraction.text import TfidfVectorizer
# TF-IDF vectorization
tfidf = TfidfVectorizer(max_features=1000, ngram_range=(1, 2))
text_features = tfidf.fit_transform(emails['text'])
# Combine with engineered features
from scipy.sparse import hstack
from sklearn.preprocessing import StandardScaler
# Scale engineered features
scaler = StandardScaler()
numeric_features = features_df.select_dtypes(include=['float64', 'int64'])
numeric_scaled = scaler.fit_transform(numeric_features)
# Combine all features
X_combined = hstack([text_features, numeric_scaled])
print(f"Combined feature shape: {X_combined.shape}")
Step 4: Model Training
Example
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import precision_score, recall_score, f1_score, roc_auc_score
# Split data (stratified for imbalanced dataset)
X_train, X_test, y_train, y_test = train_test_split(
X_combined, y, test_size=0.2, random_state=42, stratify=y
)
# Train models
models = {
'Logistic Regression': LogisticRegression(class_weight='balanced', max_iter=1000),
'Random Forest': RandomForestClassifier(n_estimators=100, class_weight='balanced'),
}
results = {}
for name, model in models.items():
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
y_proba = model.predict_proba(X_test)[:, 1]
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
auc = roc_auc_score(y_test, y_proba)
results[name] = {
'precision': precision,
'recall': recall,
'f1': f1,
'auc': auc,
'model': model
}
print(f"\n{name}:")
print(f" Precision: {precision:.3f} (goal: 99%+ to avoid false positives)")
print(f" Recall: {recall:.3f} (goal: 95%+ to catch spam)")
print(f" F1-Score: {f1:.3f}")
print(f" AUC-ROC: {auc:.3f}")
Step 5: Threshold Optimization
Example
from sklearn.metrics import precision_recall_curve
# Get best model
best_model = results['Logistic Regression']['model']
y_proba = best_model.predict_proba(X_test)[:, 1]
# Plot precision-recall tradeoff
precision_vals, recall_vals, thresholds = precision_recall_curve(y_test, y_proba)
# Find threshold for 99% precision
for i, prec in enumerate(precision_vals):
if prec >= 0.99:
optimal_threshold = thresholds[i - 1] if i > 0 else 0.5
optimal_recall = recall_vals[i]
break
print(f"Optimal threshold: {optimal_threshold:.3f}")
print(f"Precision at threshold: 99%+")
print(f"Recall at threshold: {optimal_recall:.1%}")
# Apply threshold
y_pred_optimized = (y_proba >= optimal_threshold).astype(int)
Step 6: Production Deployment
Example
from flask import Flask, request, jsonify
import pickle
app = Flask(__name__)
# Load model and vectorizer
model = pickle.load(open('spam_model.pkl', 'rb'))
tfidf_vec = pickle.load(open('tfidf_vectorizer.pkl', 'rb'))
@app.route('/classify_email', methods=['POST'])
def classify_email():
data = request.get_json()
email_text = data.get('text')
email_subject = data.get('subject', '')
# Extract features
eng_features = extract_features(email_text, email_subject)
text_vec = tfidf_vec.transform([email_text])
# Combine features
combined = hstack([text_vec, [list(eng_features.values())]])
# Predict
spam_prob = model.predict_proba(combined)[0, 1]
# Apply threshold
is_spam = spam_prob >= 0.7
return jsonify({
'is_spam': bool(is_spam),
'spam_probability': float(spam_prob),
'action': 'Block' if is_spam else 'Deliver'
})
if __name__ == '__main__':
app.run()
Performance Summary
| Best Model | Logistic Regression with Custom Threshold |
| ├─ Precision | 99.1% (only 0.9% false positives) |
| ├─ Recall | 92.3% (catches 92% of spam) |
| ├─ F1-Score | 0.955 |
| └─ AUC-ROC | 0.98 |
| ├─ Spam detected | ~923,000 |
| ├─ Legitimate blocked | ~9,000 (acceptable) |
| └─ Spam missed | ~77,000 (can add to manual review) |
Summary
This project teaches:
- Feature engineering from emails
- Handling imbalanced datasets
- Threshold optimization
- Precision vs recall tradeoffs
- Production email filtering
Continue the lesson path
Study next in this module
01ProjectsSentiment Analysis Project — Machine LearningBuild a sentiment analysis model to classify text as positive, negative, or neutral.02ProjectsRecommendation System ProjectBuild a recommendation system using collaborative filtering and content-based approaches.03ProjectsHouse Price PredictionBuild a regression model to predict house prices using features like location, size, and amenities.04ProjectsFace Recognition System — Machine LearningBuild a face recognition system using deep learning for identification and verification.