How AI Learns: An Animated Guide to Neural Networks

Lesson by Adnan, computer science lecturer  ·  aitrendblend editorial team  ·  Computer Science Education  ·  October 2026  ·  Reading time about 25 minutes

How AI Learns
An Animated Lesson

Who this lesson is for and how to use it

This is the second lesson in our Computer Science Education series. It builds directly on How a Computer Works, where students met binary, logic gates and the CPU cycle. If your class has not done that lesson, spend ten minutes on its logic gate lab first, because the XOR gate from that page comes back here in a surprising way.

The lesson is written for grades nine to twelve and for first year college students who are meeting artificial intelligence for the first time. No coding experience is required for the labs. Students who know a little Python will get more from the companion code at the end. Put the page on a projector and let pairs of students take turns at the controls. Every lab runs in the browser, works on a phone, and needs no account or installation.

Learning objectives

After three periods, a student should be able to do the following five things without notes.

1. Explain what an artificial neuron computes, using the words input, weight, bias and activation.
2. Describe how a perceptron learns from its mistakes and predict which way a weight will move after an error.
3. Explain gradient descent with the picture of a ball rolling downhill, and say what goes wrong when the learning rate is too large.
4. Give the reason a single neuron cannot learn XOR and explain why hidden layers solve it.
5. Describe a chatbot as a next word predictor and give two reasons its answers must be checked.

Programming versus learning

In the last lesson the computer followed instructions exactly. A programmer wrote every rule, and the CPU fetched and executed them one at a time. That approach works brilliantly when people can write the rules down. A calculator, a payroll system and a traffic light controller are all easy to describe in rules.

Now try writing rules for recognizing a cat in a photo. Pointy ears? Some dogs have them. Whiskers? So do seals. Fur? So does almost every mammal. After a few minutes students realize they recognize cats easily but cannot explain how. This is the problem machine learning solves. Instead of writing the rules, we show the computer thousands of labeled examples and let it adjust itself until its guesses match the labels.

That shift is the whole idea of this lesson. A traditional program is rules plus data giving answers. A machine learning system is data plus answers giving rules. The rules it discovers are stored as numbers called weights, and the process of finding them is called training.

The artificial neuron, one small calculation

The idea of an artificial neuron is older than most people expect. In 1943 Warren McCulloch, a neuroscientist, and Walter Pitts, a logician, published a paper showing that a very simplified model of a brain cell could compute logical functions. Their neuron added up signals and fired if the total passed a threshold. Students who remember the AND and OR gates from the last lesson will recognize the family resemblance straight away.

A modern artificial neuron does three things. It takes some inputs, which are just numbers. It multiplies each input by a weight that says how important that input is, and adds a number called the bias that shifts the result up or down. Then it passes the total through an activation function. The most classic choice is the sigmoid, which squashes any number into the range between 0 and 1 so the output can be read like a confidence.

Here is a decision every student has made. Should I go out and play cricket after school? Input one is how sunny it is, from 0 for pouring rain to 1 for a perfect day. Input two is how much of today’s homework is finished. The weights say how much each factor matters to you, and the bias is your general mood. Move the sliders and watch the neuron decide.

Two things usually surprise students here. First, a negative weight makes an input push the decision the other way. Set the homework weight below zero and suddenly finishing homework makes you less likely to play, which describes a very different student. Second, the bias acts like a personality. A large negative bias means the neuron needs a lot of convincing before it says yes. Nothing in the neuron understands cricket or homework. It is arithmetic, exactly the kind the ALU performed in our toy CPU.

How a machine learns from mistakes

A neuron with the wrong weights is useless. The breakthrough that made the field exciting came in 1958, when the psychologist Frank Rosenblatt at Cornell described the perceptron, a neuron that could set its own weights by learning from examples. His rule is short enough to write on one line of the board, and it is still the clearest picture of what learning means for a machine.

Show the perceptron an example. If its answer is right, change nothing. If it said 0 when the answer was 1, nudge every weight a little in the direction of that example’s inputs. If it said 1 when the answer was 0, nudge them the other way. Then move on to the next example and repeat, again and again, until it stops making mistakes.

In that rule \(t\) is the true answer, \(y\) is the neuron’s guess, and \(\eta\), the Greek letter eta, is the learning rate, a small number that keeps each nudge gentle. When the guess is right, \(t – y\) is zero and nothing moves. The whole intelligence of the method lives in that single subtraction.

Train a perceptron yourself

The plot below shows invented practice data for twelve students. The horizontal axis is hours studied before an exam and the vertical axis is hours of sleep the night before. Circles passed and squares failed. The perceptron’s job is to find a straight line that separates the two groups. Press Train until it learns and watch the dashed line swing into place. A point with a yellow outline is currently on the wrong side. You can also click anywhere on the plot to add your own students, choosing first whether they passed or failed.

One full pass through all the examples is called an epoch. On this data the perceptron usually needs around sixty epochs, which takes the lab a few seconds. A real image classifier might run dozens of epochs over millions of photos on specialized hardware. The rule it follows is a close relative of this one.

Gradient descent, walking downhill on the error

The perceptron rule works for one neuron with a yes or no answer. Bigger networks need a more general method, and almost all of them use one called gradient descent. The picture to give students is a hiker lost in fog on a hillside who wants to reach the valley floor. She cannot see the bottom, but she can feel which way the ground slopes under her feet. So she takes a step downhill, feels the slope again, takes another step, and keeps going until the ground is flat.

For a neural network the hillside is the error. Every possible setting of the weights gives some amount of error, and the job is to find the setting with the least. The slope, which mathematicians call the gradient, tells the network which direction makes the error grow. Moving the opposite way makes it shrink.

In the lab below the error curve is a simple bowl, \(L(w) = (w – 3)^2 + 1\), so we know the best weight is 3. The ball starts far away at minus 4. Press Play and watch it roll. Then try the learning rate slider. A tiny step size crawls. A medium one arrives quickly. Push it past 1.0 and something dramatic happens, which is worth letting students discover on their own before you explain it.

With a learning rate above 1.0 each step jumps past the bottom of the bowl and lands higher up the other side than where it started. The next jump is bigger still, and the ball flies off the screen. Engineers call this divergence, and choosing a sensible learning rate is one of the first practical skills anyone training a real model has to learn. Too small wastes hours of computing time. Too large and training never settles at all.

A neural network never sees the whole landscape. It only feels the slope beneath its feet and takes one careful step at a time.From this lesson, period two

Why one neuron is not enough

Now press the XOR challenge button in Lab 2 and train again. Students who did the last lesson will remember XOR as the gate that outputs 1 only when its two inputs are different. On the plot that means two opposite corners belong to one class and the other two corners belong to the other. Watch the perceptron try. The line swings back and forth for three hundred epochs and never settles, because no single straight line can put both circles on one side and both squares on the other.

This limitation was famous. In 1969 Marvin Minsky and Seymour Papert at MIT published a book called Perceptrons that proved what a single layer could and could not do, and interest in neural networks cooled for years afterwards. The answer was already sitting in the last lesson. XOR can be built by combining OR, AND and NOT. In the same way, a network with a hidden layer between input and output can combine several straight lines into a shape that separates the corners.

The difficulty was training those hidden neurons, since nobody tells you what their right answers should be. In 1986 David Rumelhart, Geoffrey Hinton and Ronald Williams published a short paper in the journal Nature describing backpropagation, a way to share out the blame for an error backwards through every layer so gradient descent can adjust all the weights at once. Backpropagation is still how almost every neural network is trained today, including the very large ones.

From one neuron to deep learning

If backpropagation existed in 1986, why did AI only seem to arrive in students’ lives recently? The honest answer is scale. Neural networks are hungry for two things, examples and arithmetic, and for decades there was not enough of either. The internet produced the examples, billions of labeled photos and pages of text. Graphics cards, the GPUs from the hardware table in our first lesson, turned out to be ideal for the arithmetic because they perform thousands of multiplications at the same time.

The moment researchers usually point to came in 2012, when a deep network built by Alex Krizhevsky, Ilya Sutskever and Geoffrey Hinton at the University of Toronto won the ImageNet image recognition competition by a large margin, trained on two consumer graphics cards. Deep simply means many hidden layers. Early layers learn to spot edges and colors, middle layers combine them into textures and shapes, and later layers combine those into whole objects. Nobody programs those stages. They emerge during training, which is still one of the most remarkable facts in computer science.

Students who want to watch hidden layers at work can try TensorFlow Playground, a free browser tool where you add layers and neurons and see the decision boundary bend into curves. Ask them to solve the XOR style pattern there with one hidden layer of four neurons, then compare it with the straight line that failed in Lab 2.

How chatbots like ChatGPT predict the next word

This is the section students care about most, so give it time. A large language model, the kind of system behind ChatGPT, Claude and Gemini, is a neural network trained on one task that sounds almost too simple. Given some text, predict what comes next. Real systems work with tokens, which are whole words or pieces of words, but thinking in words is close enough for a classroom.

The simplest possible next word predictor just counts. Read a lot of text, and every time you see a word, note which word came after it. Later, when asked what follows a word, choose from the words that followed it before, picking the common ones more often. Lab 4 does exactly that, using a short paragraph about a classroom. Generate a few sentences, then edit the training text yourself, add sentences about your own school, press Train, and watch the predictions change.

Students quickly notice two things. The output sounds like the training text, because it can only reuse patterns it has seen. And it sometimes produces sentences that are grammatical but silly, such as a computer that loves the lesson, because the model looks only one word back and has no idea what any word means.

A real language model fixes the second problem in a clever way. Instead of looking one word back, it looks at the entire conversation so far. The design that made this possible is the transformer, introduced by a team at Google in the 2017 paper Attention Is All You Need. Its key idea, attention, lets every word weigh how relevant every other word is before predicting the next one. Train a transformer with billions of weights on a large fraction of the public internet and the next word predictions become good enough to write essays, explain code and answer exam questions.

Underneath, it is still Lab 1 and Lab 3. Neurons computing weighted sums, a training loop nudging weights with gradient descent, and a final step that picks the next token from a list of probabilities, just like the bars in Lab 4. Our guide to the open source machine learning frameworks used in 2026 shows the software researchers use to build these systems at full scale, and the large language models section covers current research for older students.

Responsible use, a conversation worth having in class

Once students understand that a chatbot predicts plausible text, several important ideas follow naturally, and this is the best moment in the unit to discuss them. A model can invent a fact, a quotation or a reference that looks perfectly real, because inventing plausible text is literally its job. Researchers call this hallucination. The fix is the habit every good student already has, checking claims against a trustworthy source.

Models also learn whatever patterns sit in their training data, including unfair ones. If historical data links certain jobs mostly with one gender, a model may repeat that link. Ask students to think of a decision, such as screening job applications or recommending videos, where a biased model could cause real harm, and what kind of human check would catch it.

Finally, talk about learning itself. Using AI to explain a hard idea, to quiz yourself, or to get feedback on a draft can make a student stronger. Using it to produce work you then hand in as your own skips the very training loop that makes your own brain better. Our article on how far developers trust AI coding assistants shows that even professional programmers check AI suggestions carefully, which is a useful message for senior classes.

Misconceptions students bring to class

• AI looks up answers in a database. A trained network stores no list of answers. Everything it learned is spread across its weights, which is why it can respond to questions nobody has asked before.
• AI understands what it says. It predicts patterns in data. Whether that ever counts as understanding is a real debate among philosophers, but students should not assume it.
• Artificial neurons work like brain cells. The original idea was inspired by biology, but a modern artificial neuron is a very simple calculation, and real neurons are far more complex.
• More data always fixes everything. More data helps, but biased or wrong data teaches biased or wrong patterns, at scale.
• AI is programmed with rules by its makers. Its behavior comes mostly from training. Engineers shape it with data, architecture and later fine tuning, not line by line rules.

Where this lesson simplifies the truth

Every lab here is a teaching model, and stronger students deserve to know where the simplifications sit. Real networks rarely use the classic sigmoid in hidden layers anymore. Most use a simpler activation called ReLU that outputs zero for negative numbers and passes positive numbers straight through. The gradient descent lab uses one weight and a perfect bowl, while real error landscapes have billions of dimensions, plateaus and valleys, and training uses noisy estimates of the slope computed on small batches of data.

The next word predictor is a bigram model. It looks one word back, while a transformer looks at thousands of tokens at once. Real chatbots also go through extra stages after the next token training, where people rate answers and the model is adjusted to be more helpful and safer. None of that changes the core picture. A student who can explain the five labs on this page understands the foundation that every one of those systems is built on.

Bringing it all together

The central achievement of these three periods is a single honest explanation of artificial intelligence that a teenager can repeat to their family at dinner. An artificial neuron is a weighted sum. Learning is a loop that nudges the weights after every mistake. Gradient descent decides which way to nudge them by feeling the slope of the error. Layers of neurons can learn shapes that one neuron cannot, and when you scale that up with enough data and computing power, you get systems that recognize faces and write essays.

The conceptual shift is from seeing AI as a mysterious mind to seeing it as a trained pattern machine. That shift does not make AI less impressive. It makes it understandable, and understanding is what lets students use it well. A student who knows a chatbot predicts likely text will check its claims. A student who knows models learn from data will ask what data a model learned from.

The same ideas connect to almost every other part of computer science. Gradient descent is an optimization method used far beyond AI. The XOR story shows how a limit discovered in theory can shape a whole field for years. And the training loop links back to the fetch, decode, execute cycle from our first lesson, since every multiplication in every epoch is still a CPU or GPU instruction running on binary numbers.

There are honest limits to this lesson. It skips the calculus behind backpropagation, uses toy data, and treats chatbots at the level of a single idea rather than their full engineering. Teachers with strong mathematics classes can extend period two with the derivative of the error curve, and teachers without computers can run the human neuron game and the paper XOR grid instead of the labs.

A natural next lesson is data itself, how datasets are collected, labeled and checked for bias, followed by a short project where students train an image classifier with a free browser tool such as Google Teachable Machine. Students who started this lesson believing a chatbot simply knows things now know it learned, one small nudge at a time, and that is a far more useful thing to understand.

Companion Python code for the classroom

The program below rebuilds every lab in plain Python with no extra libraries. It computes a single neuron, trains the perceptron on the same study data and shows it failing on XOR, runs gradient descent with a sensible and a reckless learning rate, and builds the bigram next word predictor. It runs in any Python 3 setup, including free online editors on a school computer or a phone.

# How AI Learns, companion code for the aitrendblend lesson
# Runs on any Python 3 installation. No extra libraries needed.
import math
import random

random.seed(7)


# Part 1. One artificial neuron
def sigmoid(z):
    """Squash any number into the range 0 to 1."""
    return 1 / (1 + math.exp(-z))


def neuron(inputs, weights, bias):
    """Weighted sum of the inputs plus a bias, then the sigmoid."""
    z = sum(x * w for x, w in zip(inputs, weights)) + bias
    return sigmoid(z)


# Part 2. A perceptron that learns from examples
# Toy data invented for the lesson: (hours studied, hours slept) -> passed (1) or not (0)
DATA = [
    ((1, 4), 0), ((2, 5), 0), ((2, 3), 0), ((3, 4), 0), ((1, 7), 0), ((4, 3), 0),
    ((6, 7), 1), ((7, 6), 1), ((8, 8), 1), ((5, 8), 1), ((9, 5), 1), ((7, 8), 1),
]


def predict(point, w, b):
    x1, x2 = point
    return 1 if w[0] * x1 + w[1] * x2 + b > 0 else 0


def train_perceptron(data, rate=0.1, epochs=500):
    w, b = [0.0, 0.0], 0.0
    for epoch in range(epochs):
        mistakes = 0
        for point, target in data:
            error = target - predict(point, w, b)   # +1, 0 or -1
            if error != 0:
                mistakes += 1
                w[0] += rate * error * point[0]     # nudge each weight
                w[1] += rate * error * point[1]
                b += rate * error                   # nudge the bias
        if mistakes == 0:
            return w, b, epoch + 1
    return w, b, epochs


def accuracy(data, w, b):
    right = sum(predict(p, w, b) == t for p, t in data)
    return right / len(data)


# Part 3. Gradient descent on a simple loss curve, L(w) = (w - 3)^2 + 1
def gradient_descent(start=-4.0, rate=0.2, steps=25):
    w = start
    history = [w]
    for _ in range(steps):
        slope = 2 * (w - 3)       # derivative of the loss
        w = w - rate * slope      # step downhill
        history.append(w)
    return history


# Part 4. A tiny next word predictor (a bigram model)
CORPUS = """the student reads the book . the teacher reads the lesson .
the student writes the code . the computer runs the code .
the teacher writes the lesson . the student asks the teacher .
the computer reads the data . the student loves the lesson ."""


def train_bigrams(text):
    words = text.split()
    counts = {}
    for current, nxt in zip(words, words[1:]):
        counts.setdefault(current, {})
        counts[current][nxt] = counts[current].get(nxt, 0) + 1
    return counts


def next_word_probs(counts, word):
    options = counts.get(word, {})
    total = sum(options.values())
    return {w: c / total for w, c in sorted(options.items(), key=lambda kv: -kv[1])}


def generate(counts, start="the", length=8):
    out = [start]
    for _ in range(length):
        probs = next_word_probs(counts, out[-1])
        if not probs:
            break
        out.append(random.choices(list(probs), weights=list(probs.values()))[0])
    return " ".join(out)


# Smoke test
if __name__ == "__main__":
    print("Neuron output for inputs (1, 0.5):", round(neuron([1, 0.5], [0.8, -0.4], 0.1), 3))

    w, b, epochs = train_perceptron(DATA)
    print(f"Perceptron learned w={[round(v, 2) for v in w]}, b={round(b, 2)} in {epochs} epochs")
    print("Training accuracy:", accuracy(DATA, w, b))
    print("Prediction for 8 hours study, 7 hours sleep:", predict((8, 7), w, b))

    xor = [((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 0)]
    wx, bx, ex = train_perceptron(xor, epochs=100)
    print("XOR accuracy after 100 epochs:", accuracy(xor, wx, bx), "(a single line cannot do it)")

    path = gradient_descent()
    print("Gradient descent ends at w =", round(path[-1], 4), "(the best value is 3)")
    print("Too large a step diverges:", round(gradient_descent(rate=1.05, steps=10)[-1], 1))

    model = train_bigrams(CORPUS)
    print("After 'the':", {k: round(v, 2) for k, v in next_word_probs(model, "the").items()})
    print("Generated:", generate(model))

    assert accuracy(DATA, w, b) == 1.0
    assert accuracy(xor, wx, bx) < 1.0
    assert abs(path[-1] - 3) < 1e-3
    print("\nAll checks passed.")

When you run it, the perceptron should reach full accuracy on the study data in about sixty epochs, the XOR accuracy should stay at 0.5, gradient descent should end at a weight of 3, and the final line should report that all checks passed. A good extension task is to change the corpus to a few sentences in Urdu written in Roman script, or in any language your students speak, and see whether the generator still works. It does, because it never knew it was reading English in the first place.

Check your understanding

Six questions cover the whole lesson. Choose an answer for each and press Check answers to see which were right, with a short explanation for each.

Frequently asked questions

Related reading on aitrendblend