Core ML Visuals

Follow sigmoid, ReLU and GELU from local slopes to a checked XOR construction, then separate activation effects from full-network gradients.

Trace classic binary AdaBoost through five illustrative samples, normalized reweighting and three signed stump votes, with training and noise limits.

Trace Adam's two moving averages, bias correction and coordinatewise steps, then see why retained momentum can raise the current minibatch loss.

Trace request classification, policy rules and confidence gating into tool, model and human lanes, then see the cost trade-off and a confident routing error.

How to spot the odd value out using standardized distance, isolation partitioning, and local neighbourhood density.

Follow a query from key scores through normalized weights to a value blend, then inspect how a new query and score scaling change it.

How squeezing 784 numbers through 32 forces a network to learn pure structure.

How the chain rule blames each weight and fixes all of them in one backward sweep.

Two fixes for weak trees: average parallel hands to calm variance or chain fixes to melt bias.

How centering each batch steadies deep layers and buys bigger learning steps.

Why total error forms a U-curve, and how you find the sweet spot between a rigid model and a twitchy one.

How grouping unlabelled points by nearest center works, and where you pick K and where it fails.

The 2x2 table behind every classification metric, worked with 40, 10, 20 and 30 calls.

How one small kernel slides over an image and writes a feature map, with every number shown.

How stacked convolution and pooling shrink a 28x28 image to 784 features and vote for 10 classes.

How rotating the held-out slice over five folds turns one lucky split into an honest average.

How grouping by crowd density finds rings and chains, with core, border and noise calls shown.

Follow ten illustrative samples through a Gini-scored split, recursive branches and an unseen-point prediction, then inspect depth and diagonal boundaries.

How PCA keeps 85 percent of spread on two axes, and when neighbour-keeping maps serve you better.

How randomly zeroing half the units stops lazy co-adaptation, with train and test sums matched at 4.

Two networks sharpen each other through contest: a forger turns noise into pictures while a judge learns to spot the fakes.

Chain weak learners so each one corrects only the mistakes of the one before it, turning shallow trees into a strong ensemble.

Walk a loss curve from w = 2 to the bottom: read the uphill slope, flip it into a step, and watch out for flat ground.

Skip the word by word loop: read a request once with an encoder and answer with small typed heads that output choices, scores and flags.

Spend sixteen runs wisely: random search tests sixteen learning rates where a grid tests four, then spendier methods take over.

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.

Plot training error against held out error as data grows, and the gap tells you whether to buy labels or add muscle.

Start bold and finish gentle: warm the rate from 0 to 0.1, glide it down a cosine, and never decay before the loss settles.

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 add a cell highway with three gates so old context survives the trip forward.

How a network scores its own mistakes so gradients know which way to push.

Why you cannot trust training scores and how train, validation, and test splits keep you honest.

Plain steps zigzag across valleys while a velocity sum cancels sideways noise and dives forward.

Stacked neuron layers with bends between them turn straight cuts into curved borders.

Training and test error on one scale reveal whether your model is too stiff or too wiggly.

One neuron draws one straight border by weighting inputs, then fixes mistakes step by step.

Squared and cubed columns let a linear solver draw curves, until extra degrees wobble.

Small windows that keep one value per region shrink maps and forgive tiny shifts.

Bootstrap hundreds of de-correlated decision trees with random feature subspaces and combine their votes, collapsing single-tree variance from 0.33 to 0.08 without overfitting.

Let each neural block learn an additive residual correction F(x) added to identity skip x, preserving gradient flow across extreme depths without optimization degradation.

Add a regularization penalty on parameter magnitude to control model variance: contrast smooth L2 ridge shrinkage against sparse L1 lasso feature selection.

Sweep decision cutoffs to trace True Positive Rate against False Positive Rate, measuring threshold-independent ranking discrimination via Area Under the Curve.

Compress variable-length input sequences into a fixed context vector with a recurrent encoder, then unroll it autoregressively with a decoder.

Read the whole dataset for one exact step, or grab one row and step at once. The noisy path escapes ruts but needs calming to land.

Draw the widest street between two classes, anchor the boundary on border support vectors, and forgive slack crossings when data overlaps.

Preserve local neighborhood probabilities and let strangers spread, unravelling high-dimensional data clouds into faithful two-dimensional visual maps.

Freeze a pretrained body and train a small head first, then thaw the top gently. Reuse wins tiny data and fails across far domains.

Read left to right with one looping cell and a running note, then watch old words fade as gradients shrink going back.

Trace how products of local derivatives shrink or amplify gradients, then separate what identity skips and norm clipping can actually fix.

Trace Gaussian latent codes, reparameterized sampling and the reconstruction–KL objective, then see why prior sampling can still fail.

Machine learning fits patterns from data. Follow a toy classifier from labelled examples to a held-out test and see why memorization fails.

Extract dense supervision directly from raw, unlabelled data using pretext tasks like masking and contrastive pairs to pretrain foundation backbones for downstream fine-tuning.

Rebuilding pixels wastes effort on backgrounds. See how pulled pairs and pushed strangers organize meaning with zero labels.

Explore Markov Decision Processes without an answer key: master the agent-environment loop, Bellman Q-learning updates, discounted cumulative return, and reward hacking failure modes.

Big teachers cannot fit on phones. See how softened odds carry hidden structure into a small student that ships.

Lonely rows miss friendships that decide labels. See how mailed messages and averaged neighbours add context hop by hop.

Guessing whole photos in one shot yields blur. See how small noise steps and learned reversals rebuild sharp images.

Retraining giant weights costs a fortune. See how a frozen base plus a thin detour learns new skills for pennies.

Processing five words at once through softmax weights and stacked masks, instead of squeezing a sentence through one thin recurrent pipe.

One mask lets GPT predict the next word from the past, while no mask lets BERT fill a hidden word from both sides of the sentence.

Eight experts share the work while each token wakes only two, so the model holds far more knowledge than it spends compute on.

Ranked answers train a judge that lifts preferred replies from 45 to 72 percent, while DPO tunes the same lesson straight into the model.

Context prediction learns word vectors. Follow an explicit window, two vector tables, a four-word softmax, CBOW, and negative sampling.

Forty hits, ten false alarms and twenty misses give precision 0.80 and recall 0.667, and one curve shows every threshold between strict and lax.

A tree says 5.2 and a linear model says 3.1, so a trained meta-model weights them 0.1 and 0.9 to land at 3.31 near the truth of 3.5.

One tree gets 7 of 10 right while five diverse trees vote 3 to 2, canceling lone mistakes to reach 0.88 where one stalls at 0.70.

Explain black-box model decisions through local surrogate approximations and axiomatic game-theoretic Shapley value attributions.

Decompose temporal signals into trend, seasonality, and stationary noise, blending autoregressive memory with moving average shock corrections.

How models convert fuzzy semantic meaning into precise mathematical distances.

Why you shouldn't train for a fixed number of epochs, and how to reliably stop when the model actually reaches its best performance.

How TPUs trade general-purpose CPU flexibility for massive hardware-accelerated matrix multiplication using a weight-stationary systolic array.

Word embeddings map word identities to learned vectors. Follow a toy lookup, compare cosine and distance, and see the limit of one vector per word.

How raw text decomposes into discrete integer token IDs using Byte Pair Encoding, compressing sequences for Transformer self-attention while concealing character-level structure.