In this post I'm not going to try to showcase the usage of ChatGPT or other chat interfaces with AI models like Claude or OpenAI.
What I would like to share with you is the core understanding of how AI models actually work. The reality is brighter than what most people try to say about it — that AI is taking over everything.
Think about it like the Internet. When it arrived, people panicked. "It's taking over everything." And in the end? We adapted to that new reality. And in my opinion it brought a lot of light — better connection between people, helping to solve the distance, the gap of missing something when you are not right there on the spot.
I would say the same about AI.
But what we need to learn and understand is the core of every model — MATH.
"If you want to control the world, learn deep the digits." — I'm not sure if this quote actually exists or I just made it up, but something like that I'm sure I heard somewhere in the movies 😄
Ok, now the Math part. Let's learn in the most easy way the first algorithm — the core of the core 🚀
Before the math
A Baby and an AI Are Doing the Exact Same Thing
I know — the moment someone mentions "math" most people mentally check out. I get it. But give me two minutes, because what I'm about to show you completely changed how I think about AI. And honestly? It's way simpler than anyone makes it sound.
Here's what nobody tells you: the way an AI model learns is identical to the way a baby learns to walk. Same process. Same feedback loop. Different hardware.
Think about a toddler touching a hot stove. Something happens — there's a signal saying "that was wrong" — and the brain updates. The child doesn't consciously think "I must recalibrate my hand trajectory." It just adjusts. And next time, the hand stays far away.
AI training works the exact same way. The model makes a prediction, gets a signal measuring how wrong it was, and adjusts its internal settings slightly. Do that a million times and you have a trained model. That's the whole secret.
👶
How a Baby Learns
Touches something hot
Feels pain — mistake signal fires
Brain connections update automatically
Behaviour improves next time
🤖
How an AI Model Learns
Sees a training example
Makes a prediction — loss is calculated
Weights inside the model update automatically
Prediction improves next time
The only real difference? The baby's neurons are made of biology. The AI's neurons are made of math. The learning loop is the same. And once you feel that in your gut, the formula below becomes obvious rather than intimidating.
"Teaching a child to count and training an AI model are the same thing — repeated feedback until the mistake shrinks to nothing."
The Core Formula
The One Equation That Trains Every AI Model on the Planet
Every AI you've ever used — ChatGPT, Midjourney, Google Translate, the Face ID on your phone — was trained by minimising this single formula. Click each coloured part to see what it actually means in plain English.
↓ tap any coloured part to understand it ↓
Q(a, X)=1n∑i = 1 to nL(a, xi)
← Tap any coloured part of the formula above to understand it
In plain English the whole formula is just asking: "On average, how wrong is my model across all of my training examples?" That's it. The lower that number, the better your model. Training is simply the process of making it smaller and smaller over time.
Symbol
What it actually means
Think of it like...
Q(a, X)
The total score — how wrong the model is on average
Your average exam grade across the whole semester
a
The model itself — its weights, its internal settings
The student sitting the exam
X
Your entire dataset — every training example you have
Every question on every exam this semester
∑ / n
Add all individual errors up, then divide by how many there are
Sum all scores then divide to get the average
L(a, xᵢ)
How wrong the model was on one single training example
Your score on one specific exam question
Interactive Demo
Drag This Slider and Watch an AI Model Actually Train
This is the part I wish someone had shown me earlier. Below are 5 video clips that a model is learning from. Each bar shows how wrong the model currently is on that clip. Drag the slider to simulate training — watch what happens to Q as the epochs go by.
Training on 5 Video Clips
Your dataset: X = { clip₁, clip₂, clip₃, clip₄, clip₅ }
Q(a, X) — current average loss
—
See how Q shrinks with each epoch? That's the whole game. The model is failing less and less on each clip. When Q reaches near zero — the model has learned. This exact process runs inside every AI training job in the world, whether it's training for 10 minutes on your laptop or 6 months on 10,000 GPUs in a data centre.
The scale changes. The math doesn't.
Going Deeper
But How Does the AI Know It Got Something Wrong?
This is the question that unlocks everything. The model has no eyes, no feelings, no intuition. So how does it know it made a mistake?
The answer is beautiful in its simplicity: every image is just a grid of numbers. A single pixel is just a number between 0 and 255. A full image is a matrix — rows and columns of those numbers. A video is a sequence of those matrices, one per frame.
So being wrong is just... the difference between two numbers. The real image had pixel value 200. The model generated 120. The error is 80. No judgment required. Pure arithmetic. Drag the slider below and see it happen live.
Images Are Just Matrices of Numbers — Here's the Proof
Drag the slider to change model accuracy — watch the error column react
Real xᵢ — target
−
Model output
=
Error (L)
L(a, xᵢ) on this frame
formula: mean( (real − generated)² )
—
The formula uses (real − generated)² — squaring the difference. This does two things: it makes every error positive so mistakes don't cancel each other out, and it punishes large mistakes much more severely than small ones. A model that's slightly off gets a gentle nudge. A model that's wildly wrong gets hit hard.
That's exactly how you'd teach a child too, isn't it? Gentle correction for small mistakes, stronger feedback for big ones.
"An image is a matrix. A video is a sequence of matrices. A word is a vector. At the bottom of every AI model — it's all just numbers doing arithmetic."
Common Questions
Questions People Actually Ask About This
Does every AI model use this same formula?
Yes — at its core, every model from a spam filter to GPT-4 optimises some version of Q(a, X). The specific definition of L changes depending on the task — image generation, text prediction, voice recognition — but the structure is universal: average your mistakes, then make them smaller.
Do I need to be good at math to understand AI?
You need intuition, not calculation. You don't need to solve the formula by hand — computers do that billions of times per second. What you need is to understand what each part represents so you can make smart decisions about your model. Think of it like driving: you don't need to know how to build an engine, but you should know what the warning lights mean.
What is the dataset X in practice?
X is whatever you're training on. For image generation it's thousands of images. For a language model it's billions of text documents. For a video model it's video clips with captions. The bigger and more diverse your X, the better your model will perform on real-world inputs it has never seen before.
What comes after understanding the loss function?
The next step is gradient descent — the mechanism that actually adjusts the weights to make Q smaller. Imagine Q as a hilly landscape and the model as a ball trying to roll to the lowest point. We'll cover that in the next post, and once you see it visually, everything clicks into place.
The Takeaway
What You Now Understand That Most People Don't
You just looked at the formula that trains every AI model on the planet — and understood what each part does. Most people who use AI every day have no idea this exists. You do now.
And remember: the math doesn't care whether it's training a chatbot, a video generator, a medical imaging tool, or a self-driving car. The loop is always the same.
The Core Training Loop — Burn This Into Your Memory
Step 1 — Take one example xᵢ from your dataset X and run it through the model
Step 2 — Calculate L — how wrong was the prediction on that one example?
Step 3 — Average all the L values across the full dataset to get Q
Step 4 — Adjust the model's weights slightly to push Q lower
Step 5 — Repeat this thousands or millions of times. The model learns.
Next up: gradient descent — the mechanism behind step 4. It's the ball rolling downhill. And once you see it, you'll never look at AI the same way again.
document.querySelectorAll('.f-part').forEach(el => {
el.addEventListener('keydown', e => { if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); el.click(); } });
});
const explanations = {
Q: { color:'#c8401a', tag:'The Goal', tagClass:'tag-red', title:'Q(a, X) — the total risk score',
text:'This is the number that training is trying to shrink. It tells you how bad your model is right now, averaged across your whole dataset. A high Q means the model is making lots of mistakes. A low Q means it\'s learned well. Everything in AI training is aimed at making this number smaller and smaller.' },
'1n': { color:'#1a6bc8', tag:'The Fairness Fix', tagClass:'tag-blue', title:'1/n — divide by the number of examples',
text:'If you have 10,000 training clips, you divide the total error by 10,000 to get the average per clip. Without this, a larger dataset would always produce a bigger Q — which would be misleading. This makes Q a fair comparison no matter how large or small your dataset is.' },
sum: { color:'#c89a1a', tag:'The For-Loop', tagClass:'tag-red', title:'∑ — add everything up (a for-loop written in math)',
text:'Sigma (∑) is just a for-loop written in math notation. It says: go through every single example in your dataset, from example 1 all the way to example n, and add up all the individual loss values. If you can write a for-loop in code, you already understand what sigma means.' },
L: { color:'#1a8c4e', tag:'The Mistake Meter', tagClass:'tag-green', title:'L(a, xᵢ) — the error on one single example',
text:'This measures how wrong the model was on just one training example. For image and video models, it\'s literally the difference between the real pixel values and what the model generated. No human judgment involved — just arithmetic. Small L means the model was close. Large L means it missed badly.' }
};
function explainPart(key) {
document.querySelectorAll('.f-part').forEach(p => p.classList.remove('active'));
document.getElementById('fp-' + key).classList.add('active');
const d = explanations[key];
const panel = document.getElementById('explain-panel');
panel.style.borderLeftColor = d.color;
panel.innerHTML = `${d.tag}