> Make sense of AI,
one visual at a time

Equation of a Line (y = mx + c)

Logarithms

Exponentials

Vectors and the Dot Product

Vector Norms

Distance Metrics

Matrix Multiplication

A Matrix is a Transformation

Projections

Determinant

Identity, Inverse and Transpose

Rank and Linear Independence

Eigenvalues and Eigenvectors

Derivatives and Slope

The Chain Rule

Partial Derivatives and the Gradient

Mean, Mode and Median

Mean, Variance and Standard Deviation

Covariance and Correlation

Probability Basics

Conditional Probability

Bayes' Theorem

The Normal Distribution

Maximum Likelihood Estimation

Entropy and Information

Cross-Entropy and KL Divergence

Information Gain

Basis, Span and Orthogonality

Singular Value Decomposition

The Jacobian and the Hessian

Convexity and Optimisation Landscapes

Taylor Series

Expectation and Variance

Bernoulli, Binomial and Poisson

The Central Limit Theorem

Quantiles and Percentiles

Sampling Distributions and Standard Error

Confidence Intervals

Hypothesis Testing and p-values

Type I and Type II Errors

QR Decomposition and Gram-Schmidt

Cholesky and Positive-Definiteness

Matrix Calculus

Lagrange Multipliers

Jensen's Inequality

Markov Chains

Combinatorics: Permutations and Combinations

Train-Test Split Method

Feature Scaling

Data Leakage

Handling Missing Values

Outliers and Influence

Pipelines

Label Encoding Process

One-Hot Encoding

Linear Regression with OLS

Regression Assumptions

Multiple Linear Regression

R² and Adjusted R²

Evaluation Metrics for Regression

Logistic Regression

Multiclass Strategies

K-Nearest Neighbors

Confusion Matrix Analysis

Precision, Recall and F1

ROC Curve and AUC

Precision-Recall against ROC

Threshold Tuning

Decision Tree Analysis

Random Forest and Bagging

Gradient Boosting

Naive Bayes Classifier

Support Vector Machines

K-Means Clustering

Principal Component Analysis

Cosine Similarity Metric

K-Fold Cross Validation

Bias vs Variance

Learning Curves

DBSCAN: Density-Based Clustering

Hierarchical Clustering and Dendrograms

KD-Tree and Ball Tree

BIRCH Algorithm

OPTICS Clustering

Cluster Validation

Choosing k: Elbow and Silhouette

Gaussian Mixture Models

t-SNE and UMAP beside PCA

Feature and Permutation Importance

Partial Dependence, ICE and SHAP

Probability Calibration

Isolation Forest

Stacking and Voting Ensembles

Grid Search against Random Search

Ridge and Lasso Regression

Elastic Net

Label Imbalance Problem

Training on Imbalanced Dataset

Hard vs Soft Labelling

Sliding Window for Time Series

Model and Data Drift

Perceptron Classifier

Weights & Biases

Activation Functions in DL

Neural Network Visualizer

How Loss is Calculated

Softmax and Cross-Entropy

Backpropagation and the Computational Graph

Gradient Descent

PyTorch Basics

ANN in PyTorch

Linear Regression with Gradient Descent

Optimizers in Neural Networks

Optimizers in 3D

Learning Rate Scheduling

Batch Processing in Networks

Gradient Descent Batch Processing

Feature Scaling & Weight Bias

Weight Initialization Methods

Vanishing & Exploding Gradients

Gradient Clipping

Residual and Skip Connections

Batch Normalization in Deep Networks

Layer Normalization

Overfitting vs Underfitting

Model Training Curves

Dropout Regularization

Regularization Techniques

Early Stopping

Hyperparameter Tuning

Data Sparsity

Neural Network for Regression

Neural Network for Unsupervised Learning

Model Reproducibility

Model Training on CPU vs GPU

Mixed Precision and Loss Scaling

Gradient Accumulation

Label Smoothing

Embedding Layers

Autoencoders

Variational Autoencoders

Generative Adversarial Networks

Diffusion Models

Contrastive and Self-Supervised Learning

Seq2seq and Beam Search

Big-O Notation and Time Complexity

Python List Lab

Python String Lab

Python Dictionary Lab

Linear Search

Binary Search

Interpolation Search

Fibonacci Search

Bubble Sort

Selection Sort

Insertion Sort

Recursion and the Call Stack

Divide and Conquer

Merge Sort

Quick Sort

Counting Sort

Radix Sort

Stacks (LIFO)

Queues (FIFO)

Linked Lists

Hash Tables and Hashing

Binary Search Trees

Heaps and Priority Queues

Heap Sort

Trie (Prefix Tree)

Union-Find (Disjoint Set)

Graph Representations

Breadth First Search

Depth First Search

Cycle Detection

Topological Sort

Dijkstra's Algorithm

Bellman-Ford and Negative Weights

A* Pathfinding Algorithm

Minimum Spanning Tree

Two Pointers

Sliding Window

Greedy Algorithms

Backtracking Search Method

Dynamic Programming

KMP String Matching

AI Agents and Uninformed Search

ASCII Character Codes

NLP Tokenizer

Text Normalization Pipeline

Stemming vs Lemmatization

N-gram Explainer

Word Cloud Generator

Why Text Encoding is Needed in NLP

Text Encoding Techniques in NLP

How Words are Represented in Neural Networks

What are Embeddings?

How are Embeddings Generated?

How Neural Networks Process Text

What is a Sequence?

Sequential Data Preparation with Sliding Window

Normalization Techniques for Sequential Data

Limitations of ANN with Sequential Data

What is a Recurrent Cell?

How RNN Processes Text

RNN Architecture

Interactive 3D RNN Visualizer

Backpropagation Through Time

Vanishing Gradient Problem in RNN

What is LSTM?

Forget Gate in LSTM

Input Gate in LSTM

Candidate Memory in LSTM

Output Gate in LSTM

How LSTM Processes Text

What is a GRU?

What is a Bidirectional Layer?

The Attention Mechanism

Query, Key and Value

Self-Attention

Multi-Head Attention

Positional Encoding

The Transformer Architecture

Encoder-only vs Decoder-only (BERT vs GPT)

How Neural Networks Process Images

Grayscale Image Processing

RGB Image Processing

Colour Spaces: RGB and HSV

Histograms and Equalisation

Thresholding

Erosion and Dilation

Blur: Gaussian, Median and Bilateral

Convolution Kernels by Hand

Real-time Edge Detection

Resizing and Interpolation

Affine Transforms

Template Matching

Harris Corners and Keypoints

Convolutional Layer

Receptive Field

Padding in CNN

Strides in CNN

Parameter Sharing in CNN

ReLU Activation in CNN

Pooling Layer

Fully Connected Layer in CNN

1x1 Convolutions

Depthwise Separable Convolution

Dilated Convolutions

Global Average Pooling against Flatten

Calculating Parameters in CNN

CNN Architecture

Data Loaders in CNN

Image Data Augmentation

Transfer Learning with CNN

Anchor Boxes

IoU and Non-Max Suppression

Mean Average Precision

Object Detection with Bounding Boxes

ResNet and Identity Shortcuts

Semantic, Instance and Panoptic Segmentation

Semantic Segmentation and U-Net

Vision Transformer Patches

Grad-CAM

Point Operators: Brightness, Contrast and Gamma

Image Noise: Types, Models and Denoising

Image Sharpening: Unsharp Mask and Kernels

Correlation vs Convolution

Mean Shift: Non-Parametric Clustering for Segmentation

Watershed Algorithm for Image Segmentation

Sliding Window Detection: Exhaustive Search, Pyramids and NMS

VGGNet and InceptionNet: Depth vs Width in CNNs

What are Relational Databases?

What are Non Relational Databases?

Datatypes in SQL

DDL in SQL

Primary and Foreign Keys

Constraints: UNIQUE, CHECK and NOT NULL

Normalization (1NF, 2NF, 3NF) in SQL

DML in SQL

Transactions and ACID in SQL

Where Clause in SQL

NULL Handling and COALESCE in SQL

ORDER BY in SQL

Limit and Offset in SQL

CASE and Views in SQL

Aggregate Functions and the NULL Trap

SQL GroupBy Visualizer

HAVING in SQL

Query Execution Order in SQL

SQL Joins Visualizer

Self-Joins

UNION, INTERSECT and EXCEPT in SQL

Subqueries in SQL

EXISTS, IN and JOIN

Common Table Expressions in SQL

Recursive CTEs

SQL Window Functions

Regular Expressions in SQL

Indexes and Query Performance

Composite and Covering Indexes

EXPLAIN and Query Plans

Isolation Levels

Deadlocks

MVCC: How Readers Avoid Blocking Writers

Partitioning by Range and Hash

Sharding

Replication, Read Replicas and Lag

The CAP Theorem

The Document Model against Rows

Key-Value and Graph Models

OLTP, OLAP and Columnar Storage

Star Schema: Facts and Dimensions

SQL Injection and Parameterised Queries

JEV: Structured LLM Evaluation

JEV Tokenization: Parallel Choice Encoding

JEV Architecture: ChoiceHead over Qwen

Training JEV: LoRA, Grad Accum, Checkpoints

How LLMs Process Text?

Byte Pair Encoding Tokenizer

How LLMs Predict the Next Word?

What are Queries, Keys and Values in an LLM?

Causal Language Modeling

What is Masked Language Modeling?

Quantization in LLMs

LoRA in LLMs

Knowledge Distillation in LLMs

Embeddings and Vector Search

Dot Product vs Cosine Similarity for Retrieval

TF-IDF

BM25 and Sparse Lexical Retrieval

Indexing in vector databases

ANN indexing: HNSW and IVF

Chunking Strategies for RAG

Recursive chunking

Structure-aware chunking

Semantic chunking

Context-aware chunking

Parent Document Retriever

Retrieval-Augmented Generation (RAG)

Retrieval Evaluation Metrics

What is Hit Rate@k?

What is Recall@k?

What is Precision@k?

What is MRR (Mean Reciprocal Rank)?

Hybrid Search: Dense + Sparse (Reciprocal Rank Fusion)

Re-ranking: Bi-Encoders vs Cross-Encoders

Maximal Marginal Relevance (MMR)

Query Rewriting and HyDE

Multi-Query Retriever

Self-Query Retriever

Corrective RAG (CRAG)

Context Windows and the KV Cache

Fine-Tuning vs RLHF and DPO

Hallucination and Grounding

Groundedness in LLM evaluation

Correctness in LLM evaluation

Relevance in LLM evaluation

Completeness in LLM evaluation

Query, embedding and prompt caching

Permission filtering in RAG retrieval

Distributed retrieval and sharding

Hello, Python!

input() and Output

Variables and Types

Type Conversion

Numbers and Operators

Strings and Slicing

String Methods

Slicing with Step

f-strings and Formatting

Lists and Indexing

Mutability and Aliasing

Shallow vs Deep Copying

sorted() with key=

Dictionaries

Dictionary Methods

Nested Data Structures

Tuples and Unpacking

Sets and Set Operations

Booleans and Comparisons

None and Truthiness

If, Elif and Else

Nested Conditionals

Conditional Expressions

match and case

try and except

For Loops and range()

Nested For Loops

for/else and while/else

range() with step

enumerate()

zip()

List Comprehensions

Conditional Comprehensions

Dict and Set Comprehensions

While Loops, break and continue

Functions and Return Values

Function Arguments

*args and **kwargs

lambda, map and filter

Variable Scope

Reading Errors and Tracebacks

Files and with

Modules and import

Generators and yield

Classes and Objects

Inheritance

Why are Python strings immutable?

What does slicing a string cost?

Does len() count characters or bytes?

What is the difference between str and bytes?

Why does `is` sometimes work on strings?

find() vs index() vs `in` — which one?

Reverse a string

Check whether a string is a palindrome

Are two strings anagrams?

Group anagrams together

Longest substring without repeating characters

First non-repeating character

Valid parentheses

Run-length string compression

Longest common prefix

Implement substring search (strStr)

Isomorphic strings

Longest palindromic substring

Edit distance (Levenshtein)

Minimum window substring

What is a Python list underneath?

Why does [[0]*3]*3 break?

Why is `in` slow on a list but fast on a set?

Two Sum

Maximum subarray sum (Kadane)

Remove duplicates from a sorted array in place

Rotate an array by k

Product of array except self

Merge overlapping intervals

Find the duplicate number

Kth largest element

Trapping rain water

Sort an array of 0s, 1s and 2s

3Sum

Search in a rotated sorted array

Sliding window maximum

list vs tuple vs deque vs array — which and why?

How does a Python dict work?

Why must dictionary keys be hashable?

Count things with a dictionary

What is the complexity of this code?

Design an LRU cache

Longest consecutive sequence

Subarray sum equals k

When should you use a set instead of a list?

What happens if you modify a collection while looping over it?

Memoisation: caching with a dictionary

Implement a hash map from scratch

Group records and invert a dictionary

What Pydantic Is For

Your First BaseModel

Types and Coercion

Required, Optional and Defaults

Reading a ValidationError

Field Constraints

Pydantic vs Dataclasses

Nested Models

Collections of Models

Unions and Discriminated Unions

Enums and Literals

Dates, UUIDs and Decimals

Strict vs Lax Mode

field_validator

model_validator

Computed Fields

model_config

Annotated and Custom Types

Validator Modes

model_dump and model_dump_json

Aliases

Parsing JSON

Custom Serializers

JSON Schema

TypeAdapter

Generic Models

Settings Management

Pydantic with FastAPI

Performance and pydantic-core

Migrating v1 to v2

What FastAPI Is

Your First Endpoint

Path Parameters

Query Parameters

Request Bodies

Response Models

Reading a 422

HTTP Methods and Routing

Headers and Cookies

Form Data and File Uploads

Status Codes

Error Handling

APIRouter

Dependency Injection

Dependencies with yield

Sub-dependencies

Class Dependencies

Router and Global Dependencies

Dependency Overrides

async def or def

Background Tasks

Lifespan Events

Testing

OpenAPI and the Docs

Security Basics

Project Structure

What NumPy Is For

Creating Arrays

Dtypes

Shape and Reshape

Indexing and Slicing

Vectorised Arithmetic

Broadcasting