AI & Machine Learning

Take a business problem from raw data to a deployed, monitored model, with honest evaluation and real production practice throughout.

8 Weeks4 Sessions/WeekIn PersonIntermediate

Feature EngineeringModel TrainingMLOps

Share this course

Overview Curriculum Capstone Assessment Enquire

What you'll be able to do

Graduates can take a business problem from raw data to a deployed, monitored model.

Frame a business question as a prediction task with a metric tied to business cost
Explain and apply the core supervised and unsupervised algorithms, and choose between them on evidence
Build a reproducible dataset and a leak-free training pipeline
Evaluate honestly, including threshold selection, segment error analysis and model interpretation
Train a neural network and apply transfer learning where it is warranted
Package modelling code as tested, version-controlled software
Track experiments, register model versions and serve a model behind a containerised API
Monitor for drift and respond to degradation

Positioning

This course covers the standard machine learning algorithm set, how to evaluate models honestly, and how to get a model into production. It targets junior data scientist, ML and data analyst, and machine learning support roles within product teams, and prepares students for a machine learning engineering path. It does not on its own qualify a graduate for a senior Machine Learning Engineer position, since most such postings require a degree and several years of experience. This is stated at enrolment.

Who it's for

Graduates and career-switchers with quantitative comfort
Analysts moving toward modelling work
Developers adding machine learning capability
Students who want the algorithmic foundation before specialising in AI engineering

Prerequisites

Python, with pandas familiarity preferred
Basic SQL
Comfort with introductory statistics

All students complete the two-session Engineering Onboarding module before Module 1.

Tools and technologies

PythonNumPypandasscikit-learnXGBoost and LightGBMSHAPPyTorchHugging Face TransformersMLflowFastAPIDockerEvidentlyGitHub ActionsPostgreSQL

Target roles

Junior Data ScientistMachine Learning Engineer (entry)ML or Data AnalystMachine learning support within a product team

Course curriculum

8 modules · 6-8 weeks

Concepts: what machine learning is and where it fits among rules, statistics and AI systems; supervised, unsupervised and reinforcement learning; translating a business question into a prediction task; target definition; selecting a success metric before modelling; baselines; the data audit covering provenance, collection bias, missingness, label quality and leakage sources; train, validation and test discipline; time-based splits; ethics and data protection basics.
Lab: given a raw multi-table business dataset, write the problem statement, define the target, compute a naive baseline and produce a data-quality report. Identify three planted leakage traps.
Project: a one-page project charter covering question, target, metric, baseline and data risks, signed off before modelling begins.

Concepts: SQL feature extraction at the correct grain; cleaning strategies and imputation decisions; categorical encoding including one-hot, ordinal and target-safe encoding; scaling and normalisation, and which algorithms require them; outlier handling; class imbalance and its effect on metrics, including resampling and class weighting; preprocessing leakage and pipelines as the remedy; feature engineering that moves metrics, covering ratios, time-since features and aggregations; dimensionality and the curse of dimensionality; reproducibility through seeds and data versioning.
Lab: extract features in SQL, then build a leak-proof preprocessing pipeline; fit a scaler on the full dataset, observe the inflated score and correct it; run a timed feature-engineering sprint scored on validation metric.
Project: reproducible dataset build script producing a versioned feature table from raw source.

Concepts: the mathematics that changes a modelling decision, taught at the point of use; linear regression covering least squares, assumptions, residuals and multicollinearity; logistic regression covering the sigmoid, log odds, coefficient interpretation and why it remains a strong baseline; gradient descent and learning rate intuition; cost functions; regularisation through ridge, lasso and elastic net, and what each does to coefficients; k-nearest neighbours covering distance metrics, the choice of k and why scaling matters; naive Bayes covering conditional independence and its use in text classification; support vector machines covering margins, the kernel trick and cost parameters; decision trees covering splitting criteria, entropy and Gini, depth and pruning; bias and variance in operational terms.
Lab: implement linear regression and gradient descent from scratch in NumPy, then reproduce the result with scikit-learn; fit all six algorithms to the same problem under a fixed cross-validation harness and produce a comparison table covering accuracy, training time and interpretability; demonstrate the effect of scaling on k-nearest neighbours and its absence of effect on trees; tune regularisation strength and plot the coefficient path.
Project: an algorithm comparison report explaining which model you would deploy and why.

Concepts: why ensembles outperform single models; bagging and random forests covering bootstrap sampling, feature subsampling and out-of-bag error; boosting covering AdaBoost, gradient boosting, and XGBoost and LightGBM as the tabular default; stacking and blending; hyperparameter search through grid, random and Bayesian strategies, and their cost; clustering covering k-means and the choice of k, hierarchical clustering, DBSCAN, and how to evaluate a clustering without labels; dimensionality reduction covering principal component analysis, explained variance, and t-SNE and UMAP for visualisation; anomaly detection with isolation forest; association rules and recommendation basics through collaborative and content-based filtering; text representation through bag of words, TF-IDF and sentence embeddings.
Lab: tune a gradient boosting model against the Module 3 winner and quantify the gain relative to the added complexity; segment customers with k-means, validate the segments against business meaning and compare against hierarchical clustering; reduce a wide feature set with principal component analysis and measure the effect on model performance; build a simple content-based recommender.
Project: Mini-project 1: Business Prediction Model on churn, credit default or demand forecasting, delivered with charter, pipeline, algorithm comparison and a written recommendation for a non-technical stakeholder.

Concepts: limits of accuracy as a metric; precision, recall, F1 and the decision threshold as a business choice; ROC-AUC against PR-AUC under imbalance; calibration and why probabilities matter for decisions; cost analysis from the confusion matrix; regression metrics covering MAE, RMSE, R-squared and residual analysis; multi-class and multi-label evaluation; cross-validation variants and nested validation for tuning; learning curves and overfitting diagnosis; segment-level error analysis; fairness checks across groups; global and local interpretation through coefficients, feature importance, permutation importance, partial dependence and SHAP; communicating uncertainty.
Lab: tune the decision threshold against an explicit cost matrix and defend it; produce a calibration plot and recalibrate; run slice-based error analysis to rank failure segments; explain three individual predictions in plain language using SHAP; diagnose an overfitting model from its learning curve.
Project: model evaluation report covering metrics, threshold rationale, segment failures, fairness observations and interpretation.

Concepts: the perceptron and the multilayer network; activation functions and why non-linearity matters; forward pass, loss and backpropagation intuition; optimisers, learning rate schedules and batch size; overfitting controls through dropout, early stopping, weight decay and augmentation; vanishing gradients and normalisation; convolutional networks for images; sequence models and the shift to attention; transfer learning and fine-tuning a pretrained model; embeddings and semantic similarity; when deep learning is justified over gradient boosting and when it is not; GPU and cost realities.
Lab: build and train a small network in PyTorch on a tabular problem and compare it against the boosting baseline on accuracy, latency and cost; train an image classifier through transfer learning; fine-tune a pretrained text classifier and compare it against TF-IDF and boosting on the same data, then document which one you would deploy.
Project: a written decision record justifying the model family chosen for the capstone.

Concepts: why notebooks do not ship; project structure and packaging; configuration over hard-coded values; typed functions and docstrings; testing machine learning code, including unit tests for transforms, data validation tests for schema, ranges and distributions, and a model-quality gate; logging; dependency pinning; deterministic training runs; experiment tracking of parameters, metrics, artifacts and lineage; model registry and stage promotion; serialisation and versioning; batch scoring against real-time serving; training and serving skew; feature computation at inference; input validation at the API boundary; containerising model services.
Lab: refactor Mini-project 1 into an installable package with separate training and prediction entry points, a configuration file and a test suite including data validation; instrument runs with MLflow and compare fifteen of them; register the selected model; wrap it in a FastAPI service with schema validation and a health endpoint; containerise it; introduce training and serving skew, then detect it.
Project: Mini-project 2: a batch scoring job and a real-time prediction API, both loading the same registered model version.

Concepts: the machine learning lifecycle as an operational loop; automated training pipelines, scheduling, idempotency and backfills; CI/CD for models with quality gates that block promotion; shadow, canary and A/B deployment; service health against data drift, concept drift and label delay; drift detection and alert design; feedback loops and ground-truth collection; retraining triggers and their cost; rollback; incident response for silent degradation; model cards and documentation.
Lab: build a scheduled retraining pipeline with a promotion gate; simulate drift by shifting the input distribution and confirm the monitor fires; execute a rollback; produce a model card.

Capstone project

An end-to-end machine learning system for a business problem, from raw multi-table data to a monitored deployed service.

Requirements

Project charter with a metric tied to business cost
Reproducible data pipeline from source
Leak-free training pipeline in a tested package
Algorithm comparison across at least four model families, including a baseline
Evaluation report with threshold justification, segment error analysis and interpretation
MLflow-tracked experiments and a registered model
Containerised prediction API deployed at a live URL
CI/CD with a model-quality gate
Drift monitoring with a working alert
Model card and runbook
A five-minute presentation for a non-technical decision-maker

Assessment

30%Weekly labs and mini-projects

20%Code review participation

35%Capstone

15%Demo Day presentation and technical questioning

Out of scope

Deep learning research and custom architectures
GPU cluster training
Reinforcement learning beyond definition
Spark and Hadoop
LLM application development, which is covered in the Generative AI and Agent Engineering course