Core ML Visuals

Why neural networks need non-linearity, and how Sigmoid, ReLU, and GELU each solve the previous function's critical failure.

Misclassified points get louder — exponential loss as a reweighting story.

Five pictures: Adam combines momentum and variance tracking to automatically tune the learning rate for every parameter, shooting straight down narrow valleys.

How we find the rare exception in a sea of normal data.

Instead of compressing an entire sentence into one vector, attention lets the decoder look back at the full input and blend what matters for the current word.

Learn how autoencoders compress data into a latent representation to find its true underlying structure.

How a neural network measures its mistakes and assigns blame. See how the chain rule passes errors backward to update every weight.

Two ensemble strategies, two different problems: bagging trains parallel trees on random samples to squash variance; boosting chains sequential trees to fix bias one residual at a time.

How standardizing layer inputs stabilizes deep networks. See the mechanism, the train/eval asymmetry, and why it breaks on small batches.

How we find natural groupings in unlabelled data.

The 2x2 table from which every classification metric flows.

How models learn rich representations without human labels by comparing augmented views of the same image.

Five pictures: Convolution solves the translation problem by sliding a single small kernel of weights across the entire input, generating a feature map while sharing parameters.

How alternating convolution and pooling layers form a pipeline that shrinks spatial dimensions while deepening feature representations.

K-fold as a mechanism for honest error estimation — why the test set must stay sealed.

How DBSCAN discovers arbitrarily shaped clusters by defining groups as continuous regions of high density, ignoring sparse noise entirely.

Carve the data space into rectangles with a series of yes-or-no questions, predicting a single value for everyone in the same box.

How to squash high-dimensional data into a human-readable 2D map.

How randomly turning off neurons prevents neural networks from memorizing data. See the training/eval asymmetry and the ensemble effect.

Learn how a game between two networks—a generator forging data and a discriminator catching fakes—allows us to synthesize sharp, highly realistic images.

Chain weak learners so each one corrects only the mistakes of the one before it � an additive process that converts many shallow trees into a powerful ensemble.

Five pictures: stand on the loss surface, read the uphill arrow, flip it, take small steps, and see where the flat stretches fool you.

Standard models treat data points as isolated rows, but real-world data is often connected. Graph Neural Networks learn from both a node's features and its structural neighborhood.

Why random search beats grid search, how Bayesian optimisation learns from past runs, and why tuning on your test set invalidates your results.

How Lloyd's algorithm discovers groups in unlabelled data through a two-step dance of assigning points and moving centroids.

Predict a new point's class by looking at the k training points closest to it and taking a majority vote.

Training a small model to mimic a larger one by matching its probability distribution.

Diagnosing bias vs variance from data volume — what more data actually fixes.

Five pictures: How to adjust the learning rate during training to escape plateaus, avoid wild oscillations, and smoothly settle into the optimal minimum.

Fit a straight line through scattered data points by minimising the vertical errors, giving a single trend for prediction.

Bend a straight line into an S-curve to predict probabilities for yes-or-no categories.

LSTMs solve the short memory of vanilla RNNs by adding a separate cell state highway edited by three gates.

How a neural network measures its own failure. See why regression uses squared error while classification needs cross-entropy to learn.

Why you can't trust the training set — the logic of train/val/test splits.

Four pictures: plain gradient descent zig-zags slowly through narrow valleys. By saving past steps in a velocity vector, momentum cancels the noise and shoots straight down.

Stacking layers of neurons lets a network build a hierarchy of features. See how depth, width, and non-linearity combine to solve complex problems.

The gap between training and test error, diagnosed from learning curves.

The perceptron is the simplest neural network. See how one neuron draws a line, and why the XOR problem forces it to grow a hidden layer.

How adding squared and cubed features allows a simple linear model to fit curves, and why higher degrees inevitably lead to overfitting.

How pooling layers shrink feature maps, reducing computation and granting spatial invariance.

Train hundreds of trees on random slices of data, let them vote, and watch individual errors cancel each other out � leaving a model that generalises far better than any single tree.

How an agent learns from trial and error using delayed feedback and no explicit answer key.

How skip connections solve the vanishing gradient problem by creating a superhighway for information and error signals.

How L1 and L2 penalties stop models from memorising noise, and why their different geometries determine whether features get shrunk or discarded.

Ranking quality visualised — why AUC survives class imbalance where accuracy fails.

Labelled data is the bottleneck of machine learning. See how pretext tasks let models generate their own labels from unlabelled data to learn useful representations.

Sequence-to-sequence models map an input sequence to an output sequence of a different length by compressing the entire input into a single fixed-size context vector.

Five pictures: reading the whole dataset is too slow, so we draw one row at a time. The noise that adds turns out to be a feature, until it isn't.

Maximum margin — finding the widest street between two classes.

How t-SNE and UMAP squash high-dimensional data into a 2D map by preserving local neighbourhoods instead of global geometry.

Why training massive networks from scratch on small datasets fails, and how feature extraction and fine-tuning let you reuse pre-learned structure instead.

Process a sequence one step at a time by passing a hidden state forward, though it struggles to remember long-range context.

Why deep networks used to be impossible to train. See how multiplying small derivatives destroys the error signal, and how modern architecture fixes it.

Learn how variational autoencoders use a probabilistic latent space and the reparameterization trick to generate new data without voids.

From hand-written rules to learning patterns from examples. The paradigm shift that makes AI possible.

Underfitting vs overfitting as darts on a board — why complexity alone doesn't win.