Epoch0

Step0

Train loss–

Test loss–

Train acc–

Test acc–

class Aclass Btest

Decision boundary · click to add points

Loss

Accuracy

Network · neuron heat-maps · edge = weight

Weight histogram

Gradient norm

Degree3

Poly train MSE–

Poly val MSE–

MLP epoch0

MLP train MSE–

MLP val MSE–

Click / drag to add points

Error vs degree · click

MLP training curve

Step0

SGD–

Momentum–

RMSprop–

Adam–

Contour map · click to set start

Surface · drag to rotate

f − f_min (log scale)

Epoch0

Train loss–

Train acc–

Held-out acc–

Prediction–

Draw a digit

Confusion matrix (held-out)

Loss · accuracy

First-layer filters

Mistakes (true→pred)

Procedurally generated samples

Episode0

Steps0

ε now0.30

Avg return (50)–

Greedy path–

Grid world · click cells to edit

Episode return (moving average)

Inspector Hover over a canvas Move the pointer over the plots, network or grid to read exact values.

Neural Lab

Teach a small neural network to separate two classes. Watch the decision boundary form while backpropagation tunes every weight.

Speed Optimizer Learning rate Batch size L2 regularisation λ Dropout

Data

Noise Samples Train share

Click brush

Network

Hidden activation

How it works

Forward pass. Every layer computes a = σ(Wa′ + b). The last layer outputs a probability p = sigmoid(z) that a point belongs to class B.
Loss. Binary cross-entropy L = −[y·log p + (1−y)·log(1−p)] plus optional weight decay + ½λ‖W‖².
Backprop. The chain rule gives δ_out = p − y and δ_l = (W_l+1ᵀδ_l+1) ⊙ σ′(z_l), hence ∂L/∂W_l = δ_la_l−1ᵀ. Use the gradient check button to compare it with finite differences.
Optimizers. SGD w ← w − η g; momentum v ← μv + g, w ← w − ηv; Adam keeps running averages m, v of g and g² and steps by η·m̂/(√v̂+ε).
Generalisation. Compare train vs test curves: a large gap means over-fitting. Try noise ↑, more neurons, then add L2 or dropout (random units zeroed with probability p, scaled by 1/(1−p)).
Features. A single neuron cannot solve XOR with x and y only; add xy and it becomes linear. Spirals love sin x, sin y.

Edge colour: orange = positive, blue = negative; thickness ∝ |w|. Hover a neuron or an edge in the diagram.

Data

Noise σ Points

Click adds

Model

Polynomial degree Ridge / L2 λ

True functionBias–variance curves

MLP

Hidden layers Neurons per layer Learning rate

Bias, variance & over-fitting

Under-fit (high bias). Degree 0–1 cannot bend to the data: both train and validation error are high.
Over-fit (high variance). Degree 12+ threads every noisy point: train error → 0 while validation error explodes.
Decomposition. E[(ŷ−y)²] = Bias² + Variance + σ². Bias² = (mean fit − truth)²; variance = how much the fit changes between training sets (40 re-draws are simulated for the dashed curves).
Ridge. Minimises MSE + λ‖c‖²: trades a little bias for much less variance. Raise λ with a high degree and watch the wiggles flatten.
MLP. Capacity grows with width and depth; early stopping (watch the validation curve turn upward) and L2 are the remedies.

Polynomials use a Chebyshev basis on [−1, 1] and are solved in closed form (normal equations, Gaussian elimination).

Speed Gradient noise σ

Loss surface

TrailsMinima

Learning rates

Update rules

SGD θ ← θ − η g. Slow in ravines, oscillates across the steep direction.
Momentum v ← μv + g; θ ← θ − ηv. Accumulates velocity along consistent directions and damps oscillations; can overshoot.
RMSprop s ← ρs + (1−ρ)g²; θ ← θ − η g/(√s+ε). Per-parameter step sizes: steep directions get smaller steps.
Adam momentum + RMS scaling with bias correction: m̂ = m/(1−β₁ᵗ), v̂ = v/(1−β₂ᵗ), θ ← θ − η m̂/(√v̂+ε).
Try the Saddle: plain SGD hesitates near the saddle point for a long time, adaptive methods escape quickly. Raise the learning rate until an optimizer diverges (its trail goes off the chart). With gradient noise, steps jitter like mini-batch SGD.

Hidden units Learning rate Distortion strength

Draw & test

Draw a digit on the pad: it is shrunk to 14×14 pixels (what the network sees), centred, and classified live.
Click a cell in the confusion matrix to list those mistakes in the gallery.
The filters show what each first-layer neuron looks for: orange = excite, blue = inhibit.

How it works

Data. No downloads: each digit is a hand-designed stroke skeleton rendered with random rotation, shear, scale, shift, stroke width, vertex jitter and pixel noise.
Model. 196 pixels → hidden (ReLU) → 10 outputs. p = softmax(z), L = −log p_true, so ∂L/∂z = p − onehot(y).
Confusion matrix. Row = true digit, column = prediction. Off-diagonal cells show which digits get mixed up (4/9, 3/5, 7/1 …).
Caveat. The net only knows the styles it was shown: strange handwriting may fail. More distortion in training = more robustness (and lower accuracy).

Speed ε exploration γ discount α learning rate Slip probability

Show Q per actionDecay ε

Environment

Paint

Q-learning

The agent keeps a table Q(s, a): expected discounted return of taking action a in state s and acting well afterwards.
Update. Q(s,a) ← Q(s,a) + α [ r + γ·max_a′ Q(s′,a′) − Q(s,a) ]. The bracket is the temporal-difference error.
Exploration. ε-greedy: with probability ε take a random action, otherwise the arg-max. Too little ε and the agent may never find the goal; too much and it keeps stumbling.
Discount γ. Small γ makes the agent short-sighted (only cells near the goal get value); γ close to 1 spreads the value through the whole maze.
Slip. With a slippery floor the safest path (away from pits) wins over the shortest one, see the Cliff preset.
Colours show V(s) = max_a Q(s,a), arrows show the greedy policy.

Reward −0.04 per step, +1 goal, −1 pit. Episodes are capped at 120 steps.

All maths (matrix products on Float32Array, backprop, Adam, closed-form regression, Q-learning, procedural digits) is implemented from scratch in app.js: nothing is downloaded and nothing leaves your browser.