How do neural networks work?

An artificial neuron is a tiny sum. It takes some numbers in (the inputs), multiplies each by its own weight, adds them up with one extra number called the bias, and passes the total through an activation function. That's it.

Here it judges mangoes. Input x₁ is how yellow the skin is, x₂ is how soft it feels. The total is z = w₁·x₁ + w₂·x₂ + b. A step activation says "ripe" (1) if z is above zero and "not ripe" (0) if not. A sigmoid gives a smooth score between 0 and 1. ReLU gives 0 for anything below zero and z itself above it.

On the board, every spot where z = 0 lies on one straight line. The weights tilt the line and the bias slides it. So one neuron can only split things with a straight cut.

The name comes from brain cells, which BrainClear and NervousClear show. But the likeness is loose: a real neuron is a living cell with thousands of connections, chemical signals and timing. This one is multiply, add, squash.

How does it find good weights? In 1958 Frank Rosenblatt's perceptron rule: show it one example; if its guess is wrong, nudge each weight by rate × error × input. Repeat. If one straight line can split the data, this is guaranteed to find one.

Try the XOR pattern: orange in two opposite corners, blue in the other two. No single straight line can split them. One neuron draws one line, so one neuron cannot learn XOR. In 1969 Marvin Minsky and Seymour Papert proved limits like this in a famous book, and interest in neural networks cooled for years.

The fix is a hidden layer: a row of neurons between the inputs and the output. Each hidden neuron looks at the same inputs and draws its own line (the small squares show what each one sees). The output neuron then adds up their answers with its own weights. Lines combined this way make a boundary that bends, and with enough hidden neurons it can wrap around almost any shape.

Working out the answer, layer by layer from inputs to output, is called the forward pass. Watch the little lights travel along the links: bigger lights carry more (weight × input).

Every weight and bias is a parameter: a number the network learns. Here, 2 inputs → h hidden → 1 output has 4h + 1 of them. Real image networks have millions; large language models (LLMClear, coming next) have billions.

A new network starts with random weights, so its answers are nonsense. Learning means changing the weights, a little at a time, until the answers get good.

First we need a score for "how wrong": the loss. Here it is cross-entropy: near 0 when the network is confidently right, big when it is confidently wrong. Imagine the loss as a landscape: every possible set of weights is a spot on the map, and the loss is the height. Learning is walking downhill.

The gradient says which way is uphill for every weight at once. Gradient descent takes a step the other way. The step size is the learning rate. Too small and learning crawls. Too big and every step overshoots the valley floor, bounces higher up the far side, and the loss explodes.

How does the network find the gradient for a weight deep inside? Backpropagation. The error at the output is passed backwards through the same links, each neuron getting its share of the blame in proportion to its weights. That gives every weight its gradient in one backward sweep (the red lights). One pass through all the training data is an epoch.

This is just calculus done on a computer, very many times. There is no understanding inside, only numbers moving downhill.

To a computer, a picture is just numbers: one brightness value per pixel (CameraClear shows how a camera sensor makes them). This drawing pad is 16 × 16 = 256 pixels, so the network has 256 inputs.

They feed 32 hidden neurons, which feed 10 outputs, one for each digit 0 to 9. A softmax turns the 10 outputs into probabilities that add up to 100%. That is 8,554 weights and biases.

Nobody wrote rules like "a 7 has a line across the top". When you opened this chapter, the page drew 1,200 made-up digits, each with a random tilt, stretch and pen width, and trained the network on them with backpropagation. Then it tested it on 300 new ones it had never seen. Your drawing is centred and scaled first, as the famous MNIST digits were.

Big image networks don't connect every pixel to every neuron. They slide small filters across the picture: a 3 × 3 grid of weights, multiplied with the pixels under it and added up, at every position. This is convolution. The right numbers make an edge detector. In a convolutional neural network (CNN), like Yann LeCun's LeNet, the filter numbers are learned too, and the first layer's filters often end up looking like edge detectors.

It only knows digits. Draw a cat and it will still name a digit, sometimes confidently. It isn't seeing a cat and lying: it has no idea what a cat is.

A network that is too big for its data can memorise it: it bends its boundary around every single training point, including the ones that are just wrong or unlucky (noise). It then scores brilliantly on the examples it has seen and badly on new ones. This is overfitting.

That is why we always keep some test data back. Watch the two loss curves: training loss keeps falling, but when test loss turns and climbs, the network has stopped learning the pattern and started learning the noise.

Fixes: more data (harder to memorise 300 points than 30), a smaller network, stopping early, or regularisation, which gently pulls every weight towards zero so the boundary stays smooth.

Data also decides who a network works for. If one group is rare in the training data, the network learns the common group's pattern and makes more mistakes on the rare one. It is not being mean; it simply never saw enough examples. This really happens: a 2018 study found commercial face-analysis systems wrong up to 34.7% of the time for darker-skinned women, against 0.8% for lighter-skinned men, and a 2020 study found speech recognisers made about twice as many errors for Black speakers as for white speakers. In India, a voice app trained mostly on one accent or language can struggle with others.

The fix is not magic: collect data that represents everyone, measure accuracy for each group, and keep people responsible for decisions that matter.

Every network in this box does the same thing: numbers in, numbers out, with weights learned from examples. Change what the numbers mean and you get very different tools.

Photos: pixels in, labels out (your gallery search). Speech: sound in, words out (voice typing). Translation: words in, words out; India's Bhashini project builds these for Indian languages. Medicine: a network that screens eye photos for diabetic damage was tested at Aravind and Sankara Nethralaya eye hospitals in India, and matched specialist graders; a doctor still decides. Maps: networks predict traffic and arrival times.

UPI payments: as reported to Parliament, NPCI gives banks an AI/ML-based fraud monitoring system that raises alerts and can decline suspicious payments, and the RBI's innovation hub built MuleHunter.AI (announced in 2024) to spot "mule" accounts used to move stolen money. The details are not public. Every such system trades catching fraud against blocking honest payments: slide the threshold and see.

Limits. A network finds patterns in its training data. It doesn't understand the world, and it can be confidently wrong on anything unlike what it saw. It needs lots of data, which can carry unfairness in with it. Big ones need lots of energy: training GPT-3 was estimated at about 1,287 MWh of electricity, and data centres (for all uses, AI included) took about 1.5% of the world's electricity in 2024, a share that is growing.

How to think about AI: treat it as a powerful, sometimes brilliant pattern-matcher, not an oracle or a mind. Ask what data it learned from and who might be missing. Check anything important. Keep a person responsible for decisions about people. Used that way it helps doctors, farmers, students and banks every day.

Next, LLMClear opens up the biggest networks of all: large language models that predict the next word.