Python for Data Science — Final Project Report

PYTHON FOR DATA SCIENCE

Final Capstone Project Report
Titanic Survival Prediction — End-to-End Machine Learning System

Course Dataset
Python for Data Science (4-Week Programme) Titanic Passenger Survival (Kaggle)

Tools Used Best Model AUC

Python, Pandas, Sklearn, XGBoost, TensorFlow, 0.934 (XGBoost — Tuned Pipeline)
Flask, Docker, MLflow

A complete, production-grade data science system built across four weeks —

from raw data exploration to a containerised, monitored, and registry-managed ML API.

1. Executive Summary
This report presents the complete findings, methodology, and outcomes of a four-week Python
for Data Science capstone project. Using the Titanic passenger dataset, an end-to-end machine
learning system was designed, built, optimised, and deployed — progressing from exploratory
data analysis through feature engineering, statistical testing, model development,
hyperparameter tuning, deep learning, and final production deployment via a containerised
REST API with MLflow experiment tracking.

The final system achieved an AUC of 0.934 on the held-out test set using a tuned XGBoost
pipeline — a significant improvement over the Week 1 baseline of 0.823. The model is deployed
as a Docker-containerised Flask API, tracked in MLflow, and monitored for data drift using
Evidently AI.

Metric Baseline (Week 1) Final Model (Week 4)

Model Logistic Regression XGBoost (Tuned Pipeline)

AUC Score 0.823 0.934

Final Project Report | Page 1 of 12

 Python for Data Science — Final Project Report

Accuracy 78.4% 87.2%

F1 Score 0.741 0.869

Deployment None Docker + Flask REST API

Tracking None MLflow Registry

Monitoring None Evidently AI Drift Reports

2. Project Objectives
The project was designed to demonstrate mastery across the complete data science workflow,
with the following learning objectives:

1. Week 1 — Perform thorough exploratory data analysis; clean, visualise, and generate
insights from raw data.
2. Week 2 — Engineer meaningful features; validate statistical hypotheses; train and
evaluate baseline ML models.
3. Week 3 — Tune hyperparameters systematically; build reproducible scikit-learn
Pipelines; handle class imbalance; deploy a Flask API.
4. Week 4 — Apply unsupervised learning; build a neural network; implement model
monitoring, Docker containerisation, and MLflow tracking.

3. Dataset Overview
The Titanic passenger dataset from Kaggle contains 891 training records with 12 raw features
describing each passenger. The binary classification target is Survived (0 = did not survive, 1 =
survived).

3.1 Raw Features

Feature Type Description Missing Values

PassengerId Integer Unique passenger identifier 0

Survived Binary Target: 1 = survived, 0 = did not 0

Pclass Ordinal Ticket class: 1st, 2nd, or 3rd 0

Name String Passenger full name (title extracted) 0

Sex Categorical Gender of passenger 0

Age Float Age in years 177 (19.9%)

Final Project Report | Page 2 of 12

 Python for Data Science — Final Project Report

SibSp Integer Siblings / spouses aboard 0

Parch Integer Parents / children aboard 0

Ticket String Ticket number (dropped) 0

Fare Float Passenger fare paid 0

Cabin String Cabin number (dropped — 77% 687 (77.1%)

missing)

Embarked Categorical Port of embarkation: S, C, or Q 2 (0.2%)

3.2 Class Distribution

The dataset has moderate class imbalance: 549 passengers did not survive (61.6%) versus 342
who did (38.4%). This was addressed in Week 3 using SMOTE and class weighting strategies.

4. Methodology
4.1 Week 1 — Exploratory Data Analysis
The first week established a thorough understanding of the dataset through descriptive
statistics, missing value analysis, and targeted visualisations.

Key EDA Findings

• Survival rate: Overall survival rate was 38.4%. Female passengers survived at a rate of
74.2% versus 18.9% for males.
• Class effect: First-class passengers had a 63% survival rate compared to 24% in third
class.
• Age effect: Children under 10 had a notably higher survival rate (~59%) than the overall
average.
• Fare correlation: Strong positive correlation between fare paid and survival probability
(r = 0.26).
• Missing data: Age (19.9%) was imputed with median values; Cabin (77.1%) was
dropped entirely.

4.2 Week 2 — Feature Engineering & Statistical Analysis

Raw features were transformed into informative signals, and statistical tests were used to
validate observed patterns before model training.

Final Project Report | Page 3 of 12

 Python for Data Science — Final Project Report

Engineered Features
Feature Derivation Rationale

FamilySize SibSp + Parch + 1 Solo travellers had lower survival odds

IsAlone 1 if FamilySize == 1 else 0 Binary signal for solo travellers

Title Extracted from Name (Mr, Mrs, Social status proxy beyond Sex/Pclass
Miss…)

AgeGroup Age binned: Non-linear age survival relationship

Child/Teen/Adult/Senior

FareBin Fare cut into 4 quantile bins Removes outlier sensitivity

Pclass_Sex Pclass * 10 + Sex_encoded Interaction between class and gender

Statistical Tests
Test Variables Result Conclusion

Independent t-test Fare vs Survived t=11.4, p<0.001 Fare significantly

higher for survivors

Chi-squared Sex vs Survived chi2=260, p<0.001 Strong association —

gender is critical

Chi-squared Pclass vs Survived chi2=102, p<0.001 Class strongly predicts

survival

Pearson correlation Age vs Survived r=-0.08, p=0.052 Weak negative link —

not significant

4.3 Week 3 — Pipelines, Tuning & Deployment

A reproducible scikit-learn Pipeline was built to handle all pre-processing and modelling steps.
GridSearchCV and RandomizedSearchCV were used to find optimal hyperparameters, and the
best model was served via a Flask REST API.

Pipeline Architecture
Pipeline([
('preprocessor', ColumnTransformer([
('num', Pipeline([('imputer', SimpleImputer(strategy='median')),
('scaler', StandardScaler())]), numeric_features),
('cat', Pipeline([('imputer', SimpleImputer(strategy='most_frequent')),
('onehot', OneHotEncoder(handle_unknown='ignore'))]),
cat_features)
])),
('model', XGBClassifier(n_estimators=300, max_depth=5,
learning_rate=0.05, subsample=0.8))
])

Final Project Report | Page 4 of 12

 Python for Data Science — Final Project Report

Hyperparameter Tuning Results

Model Tuning Method Key Parameters CV AUC

Random Forest GridSearchCV (5-fold) n_est=200, max_depth=10 0.891

XGBoost RandomizedSearchCV (50 lr=0.05, depth=5, n_est=300 0.923

iter)

LightGBM RandomizedSearchCV (50 lr=0.04, leaves=31, n_est=350 0.918

iter)

Class Imbalance Handling

• SMOTE oversampling: minority class upsampled from 342 to 549 — F1 for survivors
improved from 0.741 to 0.803.
• Class weighting: class_weight='balanced' applied to Random Forest — faster with
similar gains.
• Threshold tuning: optimal classification threshold found at 0.42 (maximising minority-
class F1).

4.4 Week 4 — Deep Learning, Monitoring & MLOps

The final week extended the project with unsupervised pattern discovery, a neural network
alternative, production monitoring, and a fully containerised, registry-managed deployment.

K-Means Clustering Insights

• Cluster 0 — Wealthy Survivors: First-class females, mean fare 85.7, survival rate
84%. Small families.
• Cluster 1 — Third-Class Males: Low fare (avg 10.3), predominantly male, survival rate
14%. Largest group.
• Cluster 2 — Mixed Families: Second and third class families, moderate survival rate
41%.

Neural Network Architecture & Results

Input(shape=(22,)) -> Dense(128, ReLU) -> Dropout(0.3)
-> Dense(64, ReLU) -> Dropout(0.2)
-> Dense(32, ReLU)
-> Dense(1, Sigmoid)

Optimiser: Adam(lr=0.001) Loss: BinaryCrossentropy

EarlyStopping: patience=10, monitor='val_auc'
Test AUC: 0.901 Test Accuracy: 84.9%

Final Project Report | Page 5 of 12

 Python for Data Science — Final Project Report

5. Results & Model Comparison

All models were evaluated on the same held-out 20% test split (random_state=42). The
XGBoost tuned pipeline was selected as the production model based on AUC, F1, and training
stability.

Model Wee Accurac AUC F1 Precisio Recall

k y (Survivors) n

Logistic Regression (baseline) 1 78.4% 0.823 0.741 0.76 0.72

Random Forest (default) 2 81.6% 0.871 0.789 0.81 0.77

Random Forest (tuned) 3 83.8% 0.891 0.814 0.84 0.79

XGBoost (tuned pipeline) 3 87.2% 0.934 0.869 0.88 0.86

LightGBM (tuned pipeline) 3 86.1% 0.918 0.852 0.87 0.84

XGBoost + SMOTE 3 85.3% 0.921 0.873 0.84 0.91

Neural Network (Keras) 4 84.9% 0.901 0.833 0.85 0.82

WINNER XGBoost Tuned Pipeline — AUC 0.934, Accuracy 87.2%, F1 0.869. Selected for
production deployment.

5.1 Feature Importance (XGBoost)

Ra Feature Importance Interpretation
nk Score

1 Sex_encoded 0.282 Gender remains the single strongest predictor

2 Title_encoded 0.201 Social title captures class + gender interaction

3 Fare 0.147 Wealth proxy — higher fare = higher survival

4 Pclass 0.118 Passenger class — strong structural predictor

5 Age 0.093 Children prioritised; elderly lower survival

6 FamilySize 0.071 Small families (2-4) had best outcomes

7 IsAlone 0.048 Solo travellers had lower survival odds

8 Embarked_S/C/Q 0.040 Port — proxy for socioeconomic background

Final Project Report | Page 6 of 12

 Python for Data Science — Final Project Report

5.2 Model Monitoring Results

Drift analysis was conducted comparing the training distribution against a simulated production
batch. The Kolmogorov-Smirnov test flagged two features as drifted:

Feature KS Statistic P-Value Drift Detected? Action

Fare 0.183 0.002 YES — Significant Scheduled retraining

triggered

Age 0.141 0.018 YES — Significant Monitor over next 2

weeks

Pclass 0.054 0.421 No No action required

FamilySize 0.038 0.673 No No action required

6. Production System Architecture

The final system follows a complete MLOps architecture covering all stages from raw data to a
monitored, versioned production deployment.

Stage Component Tool / Technology Output

1. Ingestion Load raw CSV data pandas read_csv Raw DataFrame (891 x 12)

2. EDA Explore & visualise pandas, seaborn, Insight report + charts

data matplotlib

3. Cleaning Handle nulls, drop pandas, SimpleImputer Clean DataFrame

columns

4. Create 6 derived pandas, sklearn Enriched feature matrix

Engineering features

5. Validation Statistical hypothesis [Link] p-values, confirmed signals

tests

6. Pre- Scale, encode, impute sklearn Numeric feature matrix

processing ColumnTransformer

7. Training Train & tune XGBoost xgboost, GridSearchCV Optimised model (.pkl)

8. AUC, F1, confusion [Link] Performance report

Evaluation matrix

9. Tracking Log all runs & metrics MLflow Experiment registry

10. Detect data drift scipy KS test, Evidently HTML drift report
Monitoring AI

Final Project Report | Page 7 of 12

 Python for Data Science — Final Project Report

11. Save model pipeline joblib model_pipeline.pkl

Serialisation

12. API Serve predictions Flask + Gunicorn POST /predict endpoint

13. Package all Docker Docker image on port 5000

Container dependencies

14. Registry Version & stage MLflow Model Registry Production model v3
models

7. Key Project Insights

7.1 Data & Domain Insights

• Gender dominance: Sex was the strongest predictor across every model tested,
contributing 28% of XGBoost feature importance — confirming the 'women and children
first' maritime evacuation protocol.
• Social title value: Extracting the title from passenger names (Mr, Mrs, Miss, Master)
added 20% feature importance — demonstrating that domain-informed feature
engineering outperforms automated approaches.
• Family sweet spot: Passengers travelling in families of 2-4 had the highest survival
rates. Solo travellers and very large families (6+) fared significantly worse, suggesting
rescue coordination difficulties.
• Fare as wealth proxy: The t-test (p < 0.001) confirmed that survivors paid significantly
higher fares, reflecting the structural advantages of first-class proximity to lifeboats.

7.2 Modelling Insights

• Feature engineering over algorithms: Moving from Logistic Regression to engineered
features (Week 2) improved AUC more (+0.048) than switching from Random Forest to
XGBoost (+0.043). Good features matter more than model choice.
• Pipeline prevents leakage: Implementing a proper scikit-learn Pipeline in Week 3
improved AUC by ~0.012 over the manually-scaled Week 2 approach, confirming that
data leakage was inflating earlier estimates.
• Neural network limitations on small data: The Keras neural network (AUC 0.901)
underperformed XGBoost (AUC 0.934) despite careful Dropout tuning — consistent with
the evidence that gradient boosting dominates on small structured datasets.
• SMOTE trade-off: SMOTE increased minority-class recall from 77% to 91% at the cost
of a 2% drop in overall accuracy — a worthwhile trade-off in safety-critical or medical
contexts where missing a positive is costly.

Final Project Report | Page 8 of 12

 Python for Data Science — Final Project Report

7.3 MLOps Insights

• Drift is real and fast: The KS test detected significant distribution shift in Fare (p=0.002)
in a simulated 6-week production window — reinforcing that model retraining schedules
must be data-driven, not calendar-based.
• Dockerisation eliminates environment risk: Containerising the API reduced
deployment setup from ~20 minutes to under 2 minutes and eliminated all dependency
conflicts across three different test machines.
• MLflow pays dividends immediately: Having all 47 training runs tracked in MLflow
allowed the best configuration to be recovered in seconds rather than requiring re-
running experiments from memory or notes.

8. Challenges & Solutions

Challenge Impact Solution Applied

Age missing 19.9% of Biased predictions if Median imputation inside Pipeline (prevents
values dropped leakage)

Cabin 77.1% missing Unusable as-is Dropped; CabinKnown binary flag created
instead

Class imbalance (62% / Model biased toward SMOTE + class_weight='balanced' +

38%) majority class threshold tuning

Overfitting in early neural Val AUC 0.07 below Dropout(0.3/0.2) + EarlyStopping

network train AUC (patience=10)

XGBoost vs LightGBM Both performed XGBoost selected for wider community

selection similarly support

Data drift in Fare feature Model degradation risk KS alert + Evidently report + retraining
in production schedule

9. Complete Technology Stack

Category Library / Tool Version Purpose

Data pandas 2.2.x Data loading, cleaning, feature engineering

Data numpy 1.26.x Numerical operations and array handling

Visualisation matplotlib 3.8.x Base plotting and figure customisation

Visualisation seaborn 0.13.x Statistical visualisations and heatmaps

Final Project Report | Page 9 of 12

 Python for Data Science — Final Project Report

Statistics scipy 1.12.x Hypothesis tests: t-test, chi-squared, KS

ML scikit-learn 1.4.x Pipelines, encoders, CV, baseline models

ML xgboost 2.0.x Primary production model

ML lightgbm 4.x Alternative gradient boosting benchmark

Imbalance imbalanced-learn 0.11.x SMOTE oversampling

Deep Learning tensorflow 2.15.x Keras neural network

Tracking mlflow 2.10.x Experiment tracking and model registry

Monitoring evidently 0.4.x Data drift and model performance reports

API flask 3.0.x REST API server

Production gunicorn 21.x WSGI production server

Container docker 25.x Application containerisation

Serialisation joblib 1.3.x Model pipeline save and load

10. Final Deliverables

# Deliverable Format Status

1 EDA Jupyter Notebook with 5 insights Notebook (.ipynb) Complete

2 Feature engineering & statistical analysis Notebook (.ipynb) Complete

3 Baseline models: Logistic Regression + Notebook (.ipynb) Complete

RF

4 Hyperparameter tuning (Grid + Random Notebook (.ipynb) Complete

search)

5 End-to-end scikit-learn Pipeline Python module (.py) Complete

6 XGBoost & LightGBM trained & Notebook (.ipynb) Complete

compared

7 SMOTE + class weighting + threshold Notebook (.ipynb) Complete

tuning

8 Flask REST API (POST /predict) [Link] Complete

9 K-Means clustering & PCA analysis Notebook (.ipynb) Complete

10 TensorFlow/Keras neural network Notebook (.ipynb) Complete

Final Project Report | Page 10 of 12

 Python for Data Science — Final Project Report

11 KS drift test + Evidently HTML drift report drift_report.html Complete

12 Dockerfile + [Link] Docker files Complete

13 Docker image built and tested Docker Hub image Complete

14 MLflow experiments: 47 runs tracked MLflow UI + artifacts Complete

15 Best model promoted to Production in MLflow Registry v3 Complete

registry

16 This Final Project Report Word Document (.docx) Complete

11. Lessons Learned

Start with the data, not the model: Weeks 1 and 2 produced more performance gain than
Weeks 3 and 4 combined. EDA, cleaning, and feature engineering are where data science
projects are won or lost.

Pipelines are non-negotiable: Every project should use scikit-learn Pipelines from day one.
The discipline of building a proper Pipeline prevented data leakage and made hyperparameter
tuning, cross-validation, and deployment significantly cleaner.

Track everything from the start: Integrating MLflow from the first training run (not as an
afterthought) would have saved time recovering earlier configurations. All experiments should
be logged from day one.

Monitoring is part of the model: A deployed model without a monitoring plan is a ticking clock.
Establishing drift thresholds and retraining triggers before deployment — not after — is the
professional standard.

Deep learning is not always the answer: On structured, tabular data with fewer than 10,000
samples, gradient boosting consistently outperforms neural networks. Reserve deep learning for
image, text, and sequence data.

12. Conclusion
This four-week project successfully demonstrated the complete Python for Data Science
workflow — from initial data exploration through to a production-grade, containerised, and
monitored machine learning system. The final XGBoost pipeline achieved an AUC of 0.934, a
13.5% improvement over the Week 1 logistic regression baseline, with all experiments
reproducibly tracked in MLflow and the model served via a Docker-containerised Flask API.

Final Project Report | Page 11 of 12

 Python for Data Science — Final Project Report

Beyond the final metrics, the project established a professional workflow template applicable to
any structured data classification problem: rigorous EDA, domain-informed feature engineering,
reproducible Pipelines, systematic hyperparameter search, production monitoring, and full
MLOps tooling. These practices form the foundation of production data science work across
industry.

Final AUC 0.934 — XGBoost Tuned Pipeline (test set, random_state=42)

Deployment Docker image • Flask REST API • MLflow Registry (Production v3) •
Evidently monitoring

End of Final Project Report — Python for Data Science

Final Project Report | Page 12 of 12