AIQ
AIQ
Part of the Neural Networks lesson guide. Teaching a different grade? 🌈 Explorer (5–7) · 🔧 Builder (8–10) · ⚡ Architect (15–18)
Open with the lesson's real hook line: "Neural networks are layers of math inspired by the brain. Each layer transforms data and passes it forward. Let's explore how they work — from simple to deep."
Ask the class directly: "If I told you a neural network is 'just math,' what math operations do you think are actually happening inside one?" Let students guess — most will say something vague like "algorithms" or "code." Push for specifics: "It's really just two operations repeated over and over: multiplying numbers and adding them up, followed by one small nonlinear twist. That's it. Today we're going to see how stacking that simple operation, layer after layer, gets you image recognition and language models."
Write on the board: output = f(weight × input + bias). Say: "By the end of class
you'll be able to explain every piece of that equation, plus four real technical terms that
engineers actually use when they build these systems: universal approximation, convolution,
vanishing gradients, and dropout."
Quick diagnostic question before diving in: "If I add up 100 of these weighted-sum equations in a row, but never apply that 'small nonlinear twist' f() anywhere, what have I actually built?" Let students work it out — the answer is that a chain of purely linear operations always collapses algebraically into a single linear operation, no matter how many you stack. Say: "So without that one nonlinear step, all of deep learning would mathematically reduce to nothing more powerful than one layer. That one detail is why depth is even possible."
Use the lesson's three scenes as anchors, but go one level deeper into the mechanics at each step — this age band can handle the real "why," not just the "what."
Recap the biological picture quickly: ~86 billion neurons, connected by trillions of synapses, communicating via electrical/chemical signals. Then pivot: "An artificial neuron keeps almost none of that complexity. It takes a set of input numbers, multiplies each by its own weight, adds them together (plus one extra adjustable number called a bias), and passes the total through a simple nonlinear function called an activation function." Ask: "Why do we need that nonlinear twist at all — why not just add up weighted numbers and stop?" Guide toward the answer: stacking purely linear operations collapses mathematically into a single linear operation, no matter how many layers you add — the nonlinearity is what lets multiple layers do anything a single layer couldn't.
Introduce the universal approximation theorem here as a "wow" fact with a caveat: a single hidden layer, made wide enough, can approximate any continuous function on a bounded input range. Immediately flag the catch: "wide enough" can mean impractically large, and the theorem says nothing about how easy such a network is to train. That's precisely why real networks go deep (many layers) instead of just wide (one huge layer) — depth tends to be far more parameter-efficient in practice.
Have students work in pairs on a short calculation to make the arithmetic concrete: give them
three inputs (say, 1, 2, and 3), a set of weights (0.5, -1, and 2), and a bias of 1. Have them
compute the weighted sum by hand (1×0.5 + 2×(-1) + 3×2 + 1 = 0.5 - 2 + 6 + 1 = 5.5),
then apply a simple activation function you specify, such as ReLU (which just outputs 0 for any
negative number and passes positive numbers through unchanged) — in this case the output stays
5.5. Ask what would happen to the same calculation if one weight were negative enough to push the
whole sum below zero, and have them recompute. This is the entire "forward pass" of a single
neuron, done by hand.
Cover input/hidden/output the way the app does, then extend it: "Not every layer works the same way on every kind of data. For images, the standard building block is a convolutional layer (CNN)." Explain weight sharing and local connectivity: instead of every output connecting to every input (a "fully connected" layer), a convolutional layer slides the same small set of weights — a filter — across every position in the image, checking for the same pattern (an edge, a curve) wherever it appears. This is why CNNs are so well suited to spatial data like images: the pattern for "edge" doesn't need to be relearned separately in every corner of the picture.
Have students sketch, or trace with a finger on a printed grid of numbers, how a small 3×3 filter would slide across a 6×6 grid, multiplying and summing at each position. This doesn't need to be a full worked calculation — the goal is the intuition that the same small filter reuses its weights at every location.
Contrast this directly with a fully connected layer to make the savings concrete: "If our 6×6 image layer connected fully to just one output unit, that's 36 separate weights to learn. A 3×3 convolutional filter, reused everywhere across the image, needs only 9 weights — no matter how big the image gets. That's the practical payoff of weight sharing: dramatically fewer parameters to learn, and the same learned pattern automatically works no matter where it appears in the picture."
Cover the forward pass / backward pass (backpropagation) cycle as the app describes it, then introduce the two named failure modes and one named fix:
Vanishing gradients: Backpropagation computes how much each weight contributed to the error by multiplying together many small derivative terms, one per layer, working backward. When those terms are each less than 1 (common with certain activation functions), multiplying many of them together shrinks the result exponentially the further back you go. The practical consequence: the earliest layers — the ones closest to the raw input — end up receiving a nearly zero-sized correction and learn extremely slowly, even though later layers are training fine. This is a real historical obstacle that limited how deep networks could practically go before modern fixes existed.
Dropout: During training, dropout randomly switches off (deactivates) a fraction of neurons in a layer for each training pass. Ask: "Why would randomly breaking part of your own network on purpose ever help?" Guide toward: it prevents neurons from becoming overly dependent on a small clique of other specific neurons always being present (called co-adaptation), which forces the network to learn more redundant, robust patterns instead of fragile shortcuts — improving how well it generalizes to new data it hasn't seen.
These are meant to be argued, not just answered — let disagreement run for a minute before pulling the class back together with the guidance in parentheses.
Close with: "Every buzzword you hear about AI — deep learning, image recognition, even the chatbots you talk to — comes down to what we did today: stacked layers of weighted sums and nonlinear twists, trained by pushing errors backward and nudging weights. The 'brain' language is a helpful metaphor for beginners, but you now know the actual mechanism underneath it."
Extension activity — Spot the Architecture: Give small groups three brief, real-world AI use cases (for example: a photo app that blurs backgrounds, a spam filter that reads email text, and a music app that recommends the next song from listening history). Ask each group to argue, using today's vocabulary, which of the four ideas covered — convolution/weight sharing, depth vs. width, vanishing gradients as a design challenge, or dropout as a training trick — would matter most for that use case, and why. There's room for reasonable disagreement; the goal is applying the vocabulary to a case it wasn't explicitly written for, and being able to defend the reasoning.
For a class that finishes early, add a follow-up challenge: ask groups to identify which of the four ideas would matter least for their assigned use case, and defend that choice too. Distinguishing where a concept clearly applies from where it doesn't is a stronger signal of real understanding than only being able to name matches.