~/scryx/ml_visualized

$ compare models --same-data
clustering           → find shape without labels
linear regression    → fit a value
logistic regression  → turn line into probability
mlp                  → bend the boundary

$ rule
math first. animation second. no fog.

$ live
status: 4 models really training · controls docked below

ML / visual intuition

same data. different rules.

Not a course slide. A moving blackboard: watch how each model draws its assumption on the same points.

points: fixedrule: changestruth: visual

chapter −1 / the wall a line cannot solve XOR.

Watch it try. Accuracy parks near coin-flip. That failure is the whole reason deep learning exists.

see the fix → deep learning

training controls live in the dock ↓ they stay pinned while you scroll

the story so far

how we got here — and why I see it differently.

1957Rosenblatt’s Perceptron: one line, one vote.you just watched its descendant fail on crescents

1969Minsky & Papert prove: a single layer cannot solve XOR.chapter −1 above is that proof, animated

1986Backprop goes mainstream — blame can flow backward.the arrows in chapter 03

1998LeNet reads handwritten digits for banks.that idea trains live on /dl/ right now

2012AlexNet on GPUs: depth stops being theory.ML becomes DL

2017Attention: tokens learn who to listen to.hover the matrix on /dl/

2024FlyWire maps a whole fly brain: 140k neurons, 50M synapses.we visualized the real wiring below

Most people memorize the milestones. I rebuilt them so the failure modes are visible — that’s the scryx move.

chapter 00 / model zoo

the assumption is the shape.

Inspired by 3Blue1Brown’s trick: make the equation become geometry before asking anyone to memorize it. All four models below train live on the same crescents.

1 / 4 Start with the points.

Same dots, no model yet. The game is to ask which rule is allowed to explain them.

k-means clustering min Σᵢ ||xᵢ - μ_{cᵢ}||²

No labels. It moves centroids until nearby points agree on a cluster.

chapter 01 / boundary

a classifier is geometry pretending to be judgment.

Logistic regression computes a score, squeezes it through σ, then draws the 50% contour. The line is where the model is exactly unsure. On these crescents it keeps a pink-ringed minority it can never reach — fixing that is chapter 03’s job.

z = w₁x + w₂y + b p = σ(z) = 1 / (1 + e⁻ᶻ) boundary: p = 0.5 ⇒ z = 0

loss: —
accuracy: —
epoch: 0

chapter 02 / gradient descent

loss should be a visible argument.

The old heat-map was too foggy. This view shows the training path as a simple loss curve: each dot is one update, lower is better, the gold marker is now.

L(w,b)=−Σ[y log(p)+(1−y)log(1−p)] w ← w − η · ∇L(w)

chapter 03 / multilayer perceptron

one line fails. hidden layers fold space.

An MLP doesn’t magically “think”. It remaps the plane through hidden neurons until a messy boundary becomes drawable. The diagram below is the exact network training in chapter 00 — edge width and color are its real, current weights.

h = tanh(W₁x + b₁) // 6 bends ŷ = σ(W₂h + b₂) backprop: blame flows backward through the graph