What is a Neural Network? A Simple Visual Guide for Beginners

You've built a real machine learning model. Now we step into the technology behind almost everything people mean when they say "AI" today — image recognition, voice assistants, self-driving cars, and ChatGPT. All of it runs on one idea: the neural network.

The name sounds intimidating, but the idea is surprisingly simple. In this lesson we'll build a clear mental picture of what a neural network actually is — no heavy math, just circles, arrows, and a bit of plain arithmetic.

The one-line answer

A neural network is a system of simple connected units ("neurons") arranged in layers, that learns to turn inputs into outputs by adjusting the strength of its connections. It's loosely inspired by the brain — but really it's just a stack of small math steps repeated many times.

A neural network is not a digital brain. It's a very flexible mathematical function that learns its own settings from data.

Start with one neuron

Everything begins with a single artificial neuron. It does just three things:

1. Takes inputs — some numbers (for example: age = 25, income = 40000).
2. Weighs them — each input is multiplied by a weight (how important it is), and a bias is added.
3. Fires an output — the result is passed through an activation function that decides how strongly the neuron "fires."

In plain arithmetic, a neuron computes:

output = activation( (input1 × weight1) + (input2 × weight2) + ... + bias )

# that's it — a multiply, an add, and a squish. One neuron.

A single neuron is weak. The magic comes from connecting many of them into layers.

Neurons in layers: the network

A neural network stacks neurons into three kinds of layers:

Data flows left to right: inputs enter, each hidden neuron combines them in its own way, and the output layer delivers the prediction. Here's the whole thing as a picture:

So what does "deep" learning mean?

That's the whole secret behind the buzzword. A network with just one hidden layer is a plain neural network. Stack many hidden layers and it becomes a deep neural network — hence deep learning. More layers let the network learn richer, more abstract patterns: early layers might detect edges in an image, middle layers detect shapes, and later layers recognise a whole face.

If those relationships feel familiar, they should — we mapped out how AI, machine learning, and deep learning nest inside each other back in Lesson 2.

See one in action (5 lines of Python)

You don't need any new tools to train a neural network — scikit-learn has a simple one called MLPClassifier (MLP = Multi-Layer Perceptron, the classic neural network). Here it learns to classify handwritten digits:

from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier

X, y = load_digits(return_X_y=True)          # 8x8 images of digits 0-9
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# a network with two hidden layers (64 and 32 neurons)
model = MLPClassifier(hidden_layer_sizes=(64, 32), max_iter=500)
model.fit(X_train, y_train)

print("Accuracy:", model.score(X_test, y_test))   # ~0.97 — it reads digits!

Notice hidden_layer_sizes=(64, 32) — that's you literally describing the diagram above: two hidden layers, the first with 64 neurons, the second with 32. Everything else is the same six-step workflow from Lesson 14.

Why neural networks matter

Traditional algorithms like the ones in Lesson 10 work brilliantly on neat, tabular data. But neural networks shine on messy, high-dimensional data — images, audio, and language — where you can't easily hand-pick the features. Given enough data and layers, they discover the useful features themselves. That's exactly why deep learning, not older methods, powers today's most impressive AI.

When I first drew a neural network out as nothing but circles and arrows, the mystery fell away for me — it's not a digital brain, it's a stack of simple math steps, and once you can trace a single number forward through the layers, "deep learning" stops sounding intimidating and starts feeling buildable.

Key takeaways

• A neuron multiplies inputs by weights, adds a bias, and passes the result through an activation function.
• A neural network stacks neurons into an input layer, one or more hidden layers, and an output layer.
• Data flows forward: input → hidden → output → prediction. The network learns by adjusting the connection weights.
• Deep learning just means a neural network with many hidden layers.
• Neural networks excel at unstructured data — images, audio, and text — where they learn their own features.

You now know what a neural network is and how signals flow through it. But the real question is: how does it actually learn the right weights? That's the elegant idea of forward propagation, loss, and backpropagation — and it's exactly what we'll unpack next.

Continue the series: ← Lesson 14: Your First ML Project  ·  Next: Lesson 16 — How Neural Networks Learn →