ornith-35b

A single-artificial-neuron explorer that makes the fundamental unit of a neural network concrete. The stage shows one neuron: two or three input nodes (x1, x2, x3) as circles on the left, each connected by a wire carrying a weight (w1, w2, w3), plus a separate bias term b, all feeding a central neuron body that computes the weighted sum z = w1*x1 + w2*x2 + b and then an output a = activation(z). The weighted sum builds up term by term in a readout (w1*x1 + w2*x2 + b = z), and each wire is drawn so its colour encodes the sign of the weight (e.g. blue for positive, red for negative) and its thickness the magnitude, so the learner literally sees which inputs push the neuron up or down. A simple step or sigmoid activation turns z into the final output shown at the neuron's exit. Controls: sliders for each input value, sliders for each weight and the bias, an activation toggle (step / sigmoid), a 'show computation' toggle that reveals the term-by-term arithmetic, and a 'Reset'. Acceptance criteria: z always equals the sum of weight*input over all inputs plus the bias, and the term-by-term breakdown matches it exactly; the output a always equals activation(z); each wire's colour and thickness correctly reflect its weight's sign and magnitude; and changing any input, weight, or the bias updates z and the output consistently.

An activation-function explorer that shows why neurons need non-linearities and how the common ones differ. A graph plots the selected activation over an input range (roughly z from -6 to 6): step, sigmoid, tanh, ReLU, and leaky ReLU. A draggable marker for the input z slides along the horizontal axis; a dot rides the curve at (z, f(z)) and a readout reports the output value. A side panel names the function, shows its formula, and states its output range and where it saturates. An optional derivative overlay draws f'(z) on the same axes so the learner can see that sigmoid and tanh flatten (tiny gradient) at the extremes while ReLU's derivative is 0 or 1 - previewing the vanishing-gradient idea. An optional 'compare all' mode draws every curve faintly at once. Controls: an activation picker, a draggable input z (or slider), a 'show derivative' toggle, a 'compare all' toggle, and a 'Reset'. Acceptance criteria: each curve matches its exact formula (sigmoid = 1/(1+e^-z), tanh, ReLU = max(0,z), leaky ReLU, and a true step); the marker's reported output equals f(z) at the current z; the derivative overlay matches the true derivative of the selected function; and the stated output range and saturation behaviour are correct for each activation.

A single-neuron classifier explorer that turns weights and bias into a decision boundary. A 2D plane holds a scatter of points in two classes (two colours). One neuron with weights (w1, w2) and bias b defines the line w1*x + w2*y + b = 0, which splits the plane into two shaded half-planes; every point is classified by the side it falls on. As the learner changes the weights the line rotates and as they change the bias it slides, and a live accuracy readout counts how many points are correctly classified. The weight vector (w1, w2) is drawn as an arrow from the line, always perpendicular to it, pointing toward the positive side, to make 'weights set the orientation, bias sets the offset' visible. Controls: sliders for w1, w2, and b (or drag the line/normal arrow directly), a 'new points' button that regenerates a fresh two-class scatter, a toggle for the half-plane shading, and a 'Reset'. Acceptance criteria: the drawn boundary is exactly the line w1*x + w2*y + b = 0; changing the weights rotates the line and changing the bias translates it, both correctly; the weight-vector arrow is perpendicular to the boundary and points to the positive half-plane; and the accuracy count matches which side of the line each point actually lies on.

A forward-propagation explorer for a tiny multilayer perceptron (for example 2 inputs -> 3 hidden neurons -> 1 output), drawn as nodes with weighted edges between the layers. The learner sets the input values, then runs a propagation animation that lights up the network layer by layer: signals travel along the edges (each edge's colour/thickness encoding weight*value), every hidden and output node displays its own weighted sum and its activation, and the final prediction appears at the output. Hovering or tapping any node reveals the incoming computation that produced its value. This shows that a network is just many single-neuron computations chained in layers. Controls: input-value sliders, a 'Step' button that advances exactly one layer at a time, an 'Auto propagate' play button, a 'Randomize weights' button, and a 'Reset'. Acceptance criteria: each hidden and output node's value equals activation(sum of incoming value*weight over its inputs, plus its bias); the animation strictly flows input -> hidden -> output and never backward; the edge visuals encode the signal actually passing along them; and the final output equals a correct full manual forward pass for the current inputs and weights.

A loss-function explorer that makes 'how wrong is the model' visible. In a regression mode, a handful of data points sit on a plane with a straight model line the learner can tilt and shift; a vertical residual segment joins each point to the line, and each residual is drawn as a literal square whose area equals that point's squared error, so the mean squared error is the average of those square areas, shown live on a gauge or bar. In a classification mode, a slider sets the model's predicted probability p for the true class and the applet plots the cross-entropy loss -log(p) with the current (p, loss) point marked, so the learner sees the loss approach zero as p -> 1 and explode as p -> 0. Controls: in regression, slope and intercept sliders (or drag the line) and a toggle for the residual squares; a mode toggle between MSE and cross-entropy; in classification, the predicted-probability slider; and a 'Reset'. Acceptance criteria: the MSE readout equals the mean of the squared residuals and updates as the line moves; each residual square's area equals that point's squared error; the cross-entropy value equals -log(p), tending to 0 as p -> 1 and growing without bound as p -> 0; and the numeric loss readout always agrees with the on-screen visual.

A gradient-descent explorer that shows how a model learns by rolling downhill on its loss. The stage shows a loss landscape - a 1D loss curve (a smooth bowl, or a bumpy curve with a local and a global minimum) and optionally a 2D contour map - with a ball at the current parameter value. Each step updates the parameter by exactly minus the learning rate times the gradient (the local slope), and the gradient/tangent arrow is drawn at the ball so its direction and steepness are visible. A learning-rate slider exposes the central trade-off: too small and the ball crawls, a good value converges smoothly to the minimum, too large and it overshoots and bounces outward or diverges. Readouts show the iteration count and the current loss; in 2D mode the descent path is traced across the contour lines toward the minimum. Controls: a learning-rate slider, a 'Step' button and a 'Run' animation, a way to reposition the ball to a new start (drag or 'new start'), a landscape picker (bowl / bumpy / 2D contour), and a 'Reset'. Acceptance criteria: each step moves the parameter by exactly -(learning rate)*(gradient) and the ball stays on the curve; a small learning rate converges slowly, a moderate one converges, and a too-large one visibly overshoots or diverges; the gradient arrow points along the true local slope; and on a well-behaved run the loss readout decreases over iterations.

A backpropagation explorer built on a small computation graph or a tiny two-to-three-node network. First a forward pass flows left to right, computing intermediate values, the output, and a final loss, each shown at its node. Then backpropagation runs right to left: each node and edge lights up to show its local derivative and the accumulated gradient dLoss/dparameter obtained by multiplying local derivatives along the path (the chain rule), and every weight ends up annotated with its gradient. Forward values are drawn in one colour and backward gradients in another so the two passes are clearly distinct. The learner can change an input or a weight and re-run both passes to see how the gradients respond. Controls: input and weight sliders, a 'Forward' step, a 'Backward' step (or an auto play through both), a 'Randomize', and a 'Reset'. Acceptance criteria: the forward values are computed correctly; each weight's gradient equals the product of the local derivatives along its path to the loss (the chain rule) and matches a numerical finite-difference estimate within a small tolerance; the backward pass flows strictly output -> input; and the sign of each gradient is correct, so that a positive gradient means nudging that weight up increases the loss.

A live training explorer that puts forward pass, loss, backprop, and gradient descent together as a real training loop. A small neural network learns to separate a 2D dataset that can be linear or not - two moons, two concentric circles, or XOR. The left panel shows the data points with the network's current decision boundary as a shaded region; the right panel draws a loss-versus-epoch curve live. Pressing 'Train' repeatedly runs epochs (forward pass, loss, backprop, weight update), and the learner watches the boundary morph from a random split into one that fits the data while the loss curve falls. A hidden-layer-size (capacity) slider lets them discover that a non-linearly-separable dataset only gets solved with enough hidden units. Controls: a dataset picker (linear / moons / circles / XOR), a learning-rate slider, a hidden-layer-size slider, Train / Pause / Reset-weights buttons, and a training-speed control. Acceptance criteria: the decision boundary starts near-random and demonstrably improves as training proceeds; the loss curve trends downward over epochs (minor noise allowed); a non-linearly-separable dataset (circles or XOR) is separated only when there are enough hidden units and fails with too few; and 'Reset-weights' re-randomizes the weights and returns the boundary to an untrained state.

An overfitting-and-generalization explorer. A 1D regression has a handful of noisy points drawn from a smooth underlying trend, and the learner increases model capacity (a polynomial degree, or the number of hidden units) and watches the fitted curve go from underfit (too stiff, missing the trend) through a good fit to overfit (wiggling through every noisy point). Two losses are tracked and plotted against capacity: the training loss, which keeps falling as capacity grows, and the validation loss on held-out points, which falls and then rises - the classic U-shaped generalization curve. A regularization-strength (weight-decay) slider pulls an overfit curve back toward smoothness and narrows the train/validation gap. The held-out validation points are shown distinctly so the learner sees the model is scored on data it did not fit. Controls: a capacity slider (degree or hidden units), a regularization-strength slider, a 'Resample noise / new data' button, a toggle to show the held-out validation points, and a 'Reset'. Acceptance criteria: low capacity underfits (both training and validation loss high), high capacity drives training loss toward zero while validation loss rises (overfitting), and the best validation loss occurs at an intermediate capacity; increasing regularization visibly smooths an overfit curve and reduces the train/validation gap; and the validation loss is computed only on points the model was not fitted on.

An embeddings explorer showing how items become vectors in a space where similar things sit close together. A 2D map holds labeled points - for example words such as king, queen, man, woman, apple, orange, dog, cat - positioned so related items cluster. Selecting or hovering a point highlights its nearest neighbours under the chosen metric, drawing connecting lines annotated with the similarity scores, so the learner sees semantic neighbourhoods form. A similarity readout reports the cosine similarity between two selected points as the cosine of the angle between their vectors. A vector-arithmetic mode demonstrates the classic analogy: pick a - b + c (for example king - man + woman) and the applet draws the resulting vector with arrows and marks the nearest actual point (queen). Controls: a point/word selector, a 'nearest k' slider, a metric toggle (cosine / Euclidean), a 'vector arithmetic' mode with three pickers for a, b, c, and a 'Reset'. Acceptance criteria: the nearest-neighbour highlighting matches the actual ranking under the selected metric; the reported cosine similarity equals the cosine of the angle between the two vectors (1 for identical directions, 0 for perpendicular); semantically related points are visibly clustered; and in arithmetic mode the resultant vector's nearest point is the expected analogy answer.

An attention-mechanism explorer that reveals the heart of a transformer. A short sequence of tokens (words) is shown, each carrying small query, key, and value vectors. The learner picks a query token, and the applet computes an attention weight from that query to every token as the softmax of the scaled dot-product of the query with each key (score = query.key / sqrt(d)); the weights are drawn both as a row of weighted connection lines and as a heatmap strip where brighter means more attention, and the token's output is formed as the attention-weighted sum of the value vectors. A self-attention mode shows the full N x N attention matrix as a heatmap in which every row sums to one. Editing or randomizing a token's query/key vectors lets the learner watch attention shift toward the tokens whose keys are most similar to the query, and a temperature/scale control on the softmax sharpens or flattens the distribution. Controls: a query-token selector, a 'self-attention matrix' toggle, editable/randomizable token vectors, a softmax temperature (scale) control, a toggle for the value-weighted output, and a 'Reset'. Acceptance criteria: the attention weights equal softmax(query.key / sqrt(d)) and each attention distribution sums to one; a token attends most strongly to the tokens whose keys are most similar to its query; the output vector equals the attention-weighted sum of the value vectors; and in self-attention mode every row of the N x N matrix sums to one and brightens along the most-similar query-key pairs.