Choose your route

You can follow this in two ways. Same topics. Different emphasis.

• Route A: Career changers (software, data, analytics)Learn through implementation first so you can build projects quickly & talk confidently in interviews.

• Route B: Students (CS, maths, engineering)Convert what you already know into job-ready fluency by focusing on modelling choices, evaluation & how the maths shows up in code.

Either way your goal is simple: understand what the model is doing, diagnose what is going wrong & communicate trade offs clearly.

Why this maths matters for UK AI jobs

AI work is mostly “maths in disguise”. Even if your day job is Python, SQL, Spark or cloud deployment you are still working with vectors, matrices, probabilities, gradients & loss functions under the hood.

Hiring managers typically look for evidence you can:

1. Represent data & models correctly (vectors, matrices, embeddings, feature spaces)

2. Reason about uncertainty & performance (probability, metrics, confidence, bias variance thinking)

3. Optimise & debug training (loss functions, gradients, learning rates, regularisation, convergence)

If you can do those reliably you are maths ready for a large share of AI roles in the UK.

The only maths topics you actually need for AI roles

1) Linear algebra essentials

This is the backbone of modern AI. Features are vectors. Datasets are matrices. Model weights are matrices. Embeddings are high-dimensional vectors. Deep learning is basically lots of matrix multiplications with non-linearities in between.

What you actually need

Vectors & matrices

• Vector operations, dot product, norms

• Matrix multiplication & shapes

• Transpose

Geometry in high dimensions

• Distance & similarity (Euclidean distance, cosine similarity)

• Why scaling features changes optimisation

Projections & subspaces

• The idea of projecting onto a direction

• Enough intuition for PCA & least squares

Eigenvalues & singular values (lightweight)

• You do not need proof-heavy theory

• You do need the intuition behind PCA & why SVD is used so often

Where it shows up in real AI work

• Linear regression: Xw≈yXw \approx yXw≈y

• Logistic regression: linear model + sigmoid

• Neural networks: repeated matrix multiplies

• Embeddings: similarity search & retrieval

• PCA: dimensionality reduction

• Regularisation: norms like L2

How to learn it depending on your route

Route A

• Treat linear algebra as “how to keep shapes correct”

• Implement dot products & matrix multiplications in NumPy

• Build intuition for cosine similarity because it shows up everywhere in embeddings

Route B

• Focus on how linear algebra explains model behaviour

• Practise explaining why feature scaling matters

• Connect eigenvectors or SVD intuition to PCA & compression

Micro exercises that build job skills

1. Write a small NumPy script that checks matrix shapes end to end for a linear model.

2. Implement cosine similarity & test it on simple vectors.

3. Implement PCA with a library then explain in your own words what it is doing to your dataset.

2) Probability & statistics you will actually use

AI is full of uncertainty. Labels are noisy. Data shifts. Metrics wobble. Models overfit. This is why probability & statistics is not just theory. It is how you decide whether a model is good.

What you actually need

Probability basics

• Conditional probability

• Bayes rule at an intuitive level

• Distributions you actually see: Bernoulli, binomial, normal

Statistics for evaluation

• Mean, variance, standard deviation

• Sampling & confidence intuition

• Correlation vs causation (practical awareness)

Model evaluation & uncertainty

• Train validation test split

• Cross validation intuition

• Calibration basics for probabilistic classifiers

Common metrics & what they mean

• Accuracy vs precision vs recall vs F1

• ROC AUC in plain English

• Regression metrics like MAE & RMSE

Where it shows up in real AI work

• Setting decision thresholds for classification

• Interpreting A B tests or offline evaluation

• Understanding class imbalance & why accuracy can lie

• Confidence intervals when stakeholders ask “is it really better”

How to learn it depending on your route

Route A

• Learn probability through experiments

• Simulate coin flips then map the same idea to model predictions

• Build comfort reading confusion matrices & interpreting metrics

Route B

• Practise explaining evaluation clearly

• Connect sampling to why metrics vary run to run

• Learn calibration concepts because they matter in deployed systems

Micro exercises that build job skills

1. Create a toy imbalanced dataset then compare accuracy vs F1.

2. Compute a confidence interval for a proportion using simple approximations then explain what it means for model performance.

3. Build a threshold curve that shows precision recall trade offs as you change a probability cutoff.

3) Calculus essentials for gradients & backprop

You do not need advanced calculus for most applied AI jobs. You do need to understand derivatives enough to reason about learning rates, gradients, backprop & why training sometimes fails.

What you actually need

• The idea of a derivative as rate of change

• Partial derivatives for multivariate functions

• Chain rule

• Gradient as “direction of steepest increase”

• Enough intuition to understand backprop without fear

Where it shows up in real AI work

• Why a loss decreases during training

• Why exploding or vanishing gradients happen

• Why normalisation layers help

• Why learning rate schedules matter

How to learn it depending on your route

Route A

• Learn calculus through loss functions

• Start by plotting a simple loss curve then compute numerical derivatives

• Use automatic differentiation in PyTorch or TensorFlow but understand what it is doing conceptually

Route B

• Make sure chain rule & partial derivatives feel natural

• Connect the maths to computational graphs

• Practise explaining backprop as repeated application of chain rule

Micro exercises that build job skills

1. For a simple function like (w−3)2(w-3)^2(w−3)2 compute the derivative then implement one step of gradient descent.

2. Plot a loss surface in 2D then show how the gradient points downhill when you minimise.

3. Build a tiny neural net & print gradient norms each step to see when training becomes unstable.

4) Optimisation basics for training & tuning

Optimisation is where AI becomes practical. Training is optimisation. Hyperparameter tuning is optimisation. Even prompt tuning & retrieval ranking involve optimisation ideas.

What you actually need

• Loss functions: MSE, cross entropy

• Gradient descent & stochastic gradient descent

• Learning rate & why it is often the main knob

• Regularisation: L2, dropout intuition

• Convex vs non-convex at a basic “why this is hard” level

Where it shows up in real AI work

• Training neural nets

• Fine-tuning models

• Choosing batch size & learning rate

• Debugging non-converging training

• Hyperparameter search

How to learn it depending on your route

Route A

• Implement gradient descent from scratch once

• Then use PyTorch training loops & learn to read loss curves

• Learn a simple tuning approach like random search

Route B

• Focus on diagnosing optimisation failure

• Understand overfitting vs underfitting signals

• Learn how regularisation changes the objective & the solution

Micro exercises that build job skills

1. Implement logistic regression with gradient descent on a small dataset.

2. Train the same model with different learning rates then write down what changed & why.

3. Compare L2 regularisation strengths & show how coefficients shrink.

5) The small amount of discrete maths that helps a lot

You do not need heavy discrete maths for most AI roles. You do need practical comfort with:

• Logarithms & exponentials (softmax, log loss, probabilities)

• Basic combinatorics intuition (class imbalance thinking, sampling)

• Big O awareness for data pipelines & model inference cost

• Boolean logic basics for feature engineering & data validation

This is the kind of maths that saves you from silent mistakes & makes you faster at debugging.

A 6-week maths plan for AI jobs in the UK

This plan is designed so readers can learn while applying for roles. Aim for one portfolio output per week.

Week 1: Linear algebra for ML shapes & similarity

• Route A: vectors, dot product, norms, matrix shapes in NumPy

• Route B: connect vectors & matrices to linear models & embeddingsOutput: notebook showing cosine similarity & a clean shape-checked linear model

Week 2: Linear models as a foundation

• Route A: implement linear regression & logistic regression with NumPy

• Route B: derive the loss & explain what the coefficients meanOutput: from-scratch logistic regression + confusion matrix evaluation

Week 3: Probability & metrics that hiring managers expect

• Route A: train validation test, imbalanced classes, threshold tuning

• Route B: explain precision recall trade offs & calibration basicsOutput: classification report plus a short written explanation of metric choice

Week 4: Calculus essentials for learning

• Route A: numerical derivatives then automatic differentiation concepts

• Route B: chain rule practise then computational graph intuitionOutput: notebook demonstrating gradient descent on a simple loss & linking to model training

Week 5: Optimisation & training stability

• Route A: SGD, learning rate, batch size, regularisation

• Route B: diagnose underfitting vs overfitting & pick remediesOutput: training curves for two learning rates plus your interpretation

Week 6: Put it together in a mini deep learning project

• Route A: build a small PyTorch or TensorFlow model end to end

• Route B: focus on evaluation & error analysis with clear reportingOutput: a tidy repo with a README explaining the data, model, loss, optimisation & results

Portfolio projects that prove the maths on your CV

Project 1: “Maths-to-ML toolkit”

Build a small Python package that includes:

• Dot product, norms, cosine similarity

• A simple linear model forward pass

• Logistic regression training loop

• Basic evaluation metricsThis shows linear algebra, probability & optimisation in one place.

Project 2: “Metrics & thresholds in the real world”

Use a dataset with class imbalance then:

• Compare accuracy vs F1

• Tune thresholds for different business goals

• Explain trade offs in plain EnglishThis is highly relevant for UK industry roles.

Project 3: “Backprop in plain English”

Build a tiny neural net with PyTorch or TensorFlow then:

• Print gradient norms

• Show what happens with a bad learning rate

• Explain how chain rule drives trainingThis is a great interview talking point.

Project 4: “End to end baseline model”

Pick a simple problem then deliver:

• Data cleaning

• A baseline model

• Proper evaluation

• A short error analysisHiring managers value this because it mirrors real work.

How to describe these maths skills on your CV

Instead of listing “linear algebra” write outcomes like:

• Implemented logistic regression from scratch using vectorised NumPy operations & gradient descent

• Evaluated classifiers under class imbalance using precision recall trade offs & threshold tuning

• Diagnosed training instability by monitoring loss curves, gradient norms & learning rate schedules

• Built end to end baseline models with clear metrics, error analysis & reproducible notebooks

That reads like job readiness not coursework.

Resources for the 6-week plan & projects

Below are dependable resources that match the topics above. Encourage readers to pick one main path for practice & stick to it.

Linear algebra essentials

• MIT OpenCourseWare 18.06 Linear Algebra is a strong foundation & widely used by ML learners. MIT OpenCourseWare

• 3Blue1Brown Essence of Linear Algebra is excellent for intuition & mental models. YouTube

Probability & statistics

• Khan Academy Statistics & Probability covers the exact basics used in ML evaluation. khanacademy.org

Calculus for gradients

• 3Blue1Brown Essence of Calculus gives the intuition needed for derivatives & chain rule style thinking. YouTube

• Khan Academy Differential Calculus is a structured path if readers prefer step by step practice. khanacademy.org

Machine learning foundations that connect maths to models

• Stanford CS229 lecture notes are a solid reference for classical ML & the maths behind it. cs229.stanford.edu

Practical deep learning learning paths

• fast.ai Practical Deep Learning for Coders is hands-on & designed for people with coding experience. Practical Deep Learning for Coders

• Deep Learning Book by Goodfellow, Bengio & Courville is a thorough reference with a free online version. deeplearningbook.org

Framework tutorials for project building

• PyTorch Tutorials are a reliable starting point for training loops, autograd & practical modelling. PyTorch Docs

• TensorFlow tutorials run in Colab & are beginner friendly for end to end projects. TensorFlow

• scikit-learn supervised learning guide is perfect for classical ML baselines & evaluation workflows. scikit-learn

Next steps

1. Choose Route A or Route B then follow the 6-week plan.

2. Publish one clean output per week in a GitHub repo with a short README.

3. Update your CV using outcome-based bullets.

4. Apply for UK roles using titles like Machine Learning Engineer, AI Engineer, Applied Scientist, Data Scientist plus keywords like PyTorch, TensorFlow, scikit-learn, model evaluation, optimisation, MLOps.