What Is a Neural Network? A Plain-English Explanation
What is a neural network? See exactly how weights, layers, and activation functions work through one worked example, then how it differs from an LLM.
A neural network is not a tiny brain bolted onto a computer chip. It has no neurons that fire the way yours do, no biological wiring, and it doesn't “think” before it answers. That comparison gets repeated so often it quietly stands in for the real explanation. So what is a neural network, mechanically? It's a stack of weighted arithmetic: numbers going in, numbers being multiplied and added, and numbers coming out. Once you see the arithmetic, the mystery mostly evaporates.
This is the mechanical layer underneath how AI models work in general, and it's worth understanding on its own before any of the AI product terminology makes sense.
What a Neural Network Actually Is
Start with the two words that do all the work: weight and layer.
A weight is just a number that says how much one input matters relative to the others. A big weight means big influence on the outcome. A small or negative weight means small or negative influence. That's the entire concept, it's a multiplier, not a metaphor.
A layer is a group of these weighted sums computed side by side. Each one is called a unit (older material calls it a “neuron”, which is where the biology confusion started). Each unit takes in several numbers, multiplies each by its own weight, adds them together along with one more number called a bias, and passes the result through a small function called an activation function. The activation function decides whether that sum counts as a strong enough signal to pass forward, or gets squashed toward zero. Text and images get converted into these input numbers first, a step covered in what an embedding in AI actually is. Stack several layers so one layer's output becomes the next layer's input, and you have a neural network.
A Worked Example: One Weighted Decision
Here's the arithmetic in full, with real numbers, for a single unit deciding whether to recommend an umbrella. Three inputs, each scaled between 0 and 1:
Cloud cover: 0.8
Rain forecast: 0.6
Wind speed: 0.2
Each input has a weight the network has learned matters:
Cloud cover weight: 0.5
Rain forecast weight: 1.2
Wind speed weight: 0.3
Add a bias of −0.9, a fixed number that forces the unit to require real evidence before it says yes. The weighted sum is:
(0.5 × 0.8) + (1.2 × 0.6) + (0.3 × 0.2) − 0.9
= 0.4 + 0.72 + 0.06 − 0.9
= 0.28An activation function then looks at that 0.28. A simple version just checks whether the sum is positive: if yes, output “bring an umbrella”, if no, output “skip it”. 0.28 is positive, so this unit fires. Notice that the rain forecast weight (1.2) is more than double the cloud cover weight (0.5), so a rise in rain forecast swings the decision harder than an equal rise in cloud cover would. That's what a weight does, it sets how much one input is allowed to matter. Real networks chain thousands or billions of these tiny weighted decisions together, but no individual one is doing anything more exotic than the umbrella example above.
How Do Neural Networks Learn?
A freshly initialized network starts with random weights, so its first guesses are close to noise. Training is the process of correcting them, and it runs in a loop:
Run an example through the network and record its output (a forward pass).
Compare that output to the correct answer and measure how wrong it was (the loss).
Work backward through the network to figure out which weights contributed most to that error, using an algorithm called backpropagation.
Nudge every weight slightly in the direction that would have reduced the error, a step called gradient descent.
Repeat that cycle over millions of examples and the weights drift from random noise toward values that reliably produce correct-ish outputs. There's no comprehension happening in step three, it's calculus applied mechanically, the chain rule used layer by layer to assign blame to each weight. NVIDIA's technical rundown of gradient descent and backpropagation walks through the math if you want it in full. Adjusting an already-trained network's weights further on a narrower set of new examples, rather than starting from scratch, is what fine-tuning in AI refers to.
Is a Neural Network the Same Thing as an LLM?
No. A large language model is a specific, very large kind of neural network, trained a specific way, not a synonym for the whole category. Three differences matter:
Architecture: most LLMs are built from a design called a transformer, which adds a mechanism called attention that lets every word in a sentence weigh the relevance of every other word before making a prediction. Google's transformer explainer walks through the mechanics. The umbrella-deciding unit above has no such mechanism, it only looks at its own three inputs.
Scale: the umbrella example has four numbers to learn, three weights and one bias. A production LLM has tens or hundreds of billions of weights spread across dozens of stacked layers.
Training objective: LLMs are trained on one narrow, repeatable task run at enormous scale, predicting the next word in a sequence of text, over trillions of words of source material.
The underlying mechanism, weights, layers, activation functions, backpropagation, is identical to what's described above. Scale and the transformer architecture are what turn that same mechanism into something that can hold a conversation. Most large models today are also foundation models, meaning they're trained once on broad data and reused across many downstream tasks rather than built from scratch each time.
So: every LLM is a neural network. Most neural networks are not LLMs. A spam filter, a handwriting recognizer, and a photo classifier are all neural networks too, most of them small enough to run on a phone, and most of them built years before anyone said “LLM” out loud. IBM's overview of neural networks covers that wider family in more depth. Networks that combine several input types at once, text with images or audio, extend the same weights-and-layers idea into multimodal AI.
Frequently Asked Questions
Is ChatGPT a neural network?
Yes. ChatGPT runs on a large language model, and an LLM is a neural network, specifically a transformer-based one with billions of weights trained on text. Calling it “just a neural network” undersells the scale, but the underlying mechanism, weighted sums passed through activation functions, is the same one described above.
What does “weight” mean in a neural network, in plain terms?
A weight is a number that multiplies one input to say how much that input should count toward the final result. Training adjusts these numbers over and over. Nothing else about the network's structure changes during training, only the weights and biases move.
How many layers does a network need before it counts as “deep”?
There's no official cutoff, but “deep learning” generally refers to networks with more than two or three hidden layers stacked between the input and the output. Modern LLMs stack dozens of them.
Why do neural networks need so much training data?
Because every weight starts near a random value and shifts only a small amount per example during gradient descent. With too few examples, the weights never settle on values that generalize past what they were shown, they just memorize the training set instead of learning the underlying pattern.
How did this land?
About the author
Senior Editor, AI & Product
Cecilia leads the Swarmz editorial desk. She has spent a decade turning complex AI and product topics into writing people actually finish, and she owns the blog's quality bar.
