What machine learning is and how it actually works
You type a question into a chatbot, and it answers in two seconds. You open your banking app, and it flags a transaction you didn't make. Your inbox sorts spam before you ever see it. None of these systems were told what to do step by step. They were shown examples, and they figured out the pattern on their own.
That's machine learning in one sentence: instead of writing rules, you feed a system data and let it extract the rules. Sounds simple. The mechanics behind it are where most explanations get lazy, and I want to fix that here.
A quick example from my own work. A few years ago I built a small model to predict whether an online shop visitor would complete a purchase. Classic problem, nothing exotic. I had about 40,000 sessions of historical data. Nobody coded a rule like "if user browses three products and leaves, send a discount." I gave the model the session data, and it produced the rule itself — with an accuracy around 71%, which for that messy dataset was honestly better than I expected.
Key Takeaways
- Machine learning is a branch of AI where systems learn patterns from data instead of following hand-written rules.
- Training works through a loop: predict, measure the error, adjust, repeat — often thousands of times.
- Three main families exist: supervised, unsupervised, and reinforcement learning.
- ChatGPT is both AI and machine learning — it's a generative model trained on enormous text datasets.
- You don't need a PhD to work with ML, but basic statistics and Python help enormously.
- The single biggest trap for beginners is overfitting: a model that memorizes instead of learning.
What is machine learning in simple words?
Picture teaching a child to recognize dogs. You don't hand them a rulebook listing ear shapes and tail lengths. You point at animals and say "dog," "not a dog," over and over. After enough examples, they get it — and they can identify a breed they've never seen.
Machine learning works the same way. You show an algorithm thousands of labeled examples, it adjusts its internal parameters until it can classify or predict new cases it hasn't seen before. The formal name for this is learning from data, and the output is a model — essentially a mathematical function that maps inputs to outputs.
Why the shift from rules to data matters
Traditional software is deterministic. A developer writes: if the balance is below zero, block the card. The machine executes exactly that, forever, no matter how the world changes.
ML inverts the logic. You give the system a goal — "predict fraud" — and a pile of past transactions. It works out which combinations of features (amount, location, time of day, merchant type) tend to precede fraud. The trade-off? You get flexibility in exchange for transparency. A rule you can read; a model with 40 million parameters you mostly cannot.
That trade-off is the whole story of the field. More capability, less legibility.
How do machine learning systems make decisions or predictions?
This is the part almost every explainer skips. So let's go through the actual loop.
Suppose you want a model to estimate house prices. You feed it features: square meters, number of rooms, neighborhood, age of the building. The model makes a guess. It's wrong — probably badly wrong at first. Then three things happen:
- Loss calculation. A loss function measures the gap between the guess and the real price. Wrong by €80,000? That's your error signal.
- Gradient descent. The algorithm nudges every internal parameter in the direction that reduces that error. Tiny adjustments, millions of them.
- Repeat. Once through the whole dataset is one epoch. You typically run dozens or hundreds of epochs.
After enough iterations, the predictions stop improving. That's when you stop — or when you should stop, which is a different problem.
Why you split your data three ways
Here's where I made my first serious mistake. I trained a model, checked its accuracy on the same data, saw 94%, and felt like a genius. Then I ran it on new data and it collapsed to 58%.
What happened: the model had memorized the training set instead of learning general patterns. This is overfitting, and it's the most common way beginners fool themselves.
The fix is splitting your data:
- Training set: what the model learns from (roughly 70%)
- Validation set: used to tune settings during development
- Test set: touched once, at the very end, to get an honest number
Never let the test set leak into training. Not once. I've seen a team burn two months because someone forgot to exclude a few rows.
The three families of learning
| Type | How it learns | Typical use |
|---|---|---|
| Supervised | From labeled examples (input → known answer) | Spam filters, price prediction, medical imaging |
| Unsupervised | From unlabeled data, finding structure on its own | Customer segmentation, anomaly detection |
| Reinforcement | Trial and error with rewards and penalties | Game-playing agents, robotics, recommendation tuning |
Within supervised learning you'll hear two more words constantly: regression (predicting a number) and classification (predicting a category). Same family, different output shape.
Is ChatGPT AI or machine learning?
Both. And that's not a dodge — it's the correct answer.
AI is the broad field: any system that performs tasks we'd call intelligent. Machine learning is a subset of that field. A large language model like ChatGPT is a machine learning system, specifically a generative one, trained on vast amounts of text to predict the next token in a sequence.
Strip away the interface and that's all it does at its core. Predict what comes next. Do that exceptionally well across billions of parameters, and you get something that writes code, summarizes contracts, and argues about philosophy.
So the hierarchy is: AI ⊃ machine learning ⊃ deep learning ⊃ large language models. ChatGPT sits at the bottom of that chain, inheriting every property above it.
Is machine learning difficult?
Honestly? The concepts are harder to internalize than to learn, and the tooling has gotten dramatically easier.
What you actually need:
- Comfortable with basic statistics — mean, variance, probability, distributions
- Some linear algebra, mostly to understand what's happening under the hood
- Python, and a library like scikit-learn or PyTorch
- Patience for cleaning messy data, which is where most of the real time goes
My own path: I started with a free online course, understood maybe half of it, then spent a month building small projects before anything clicked. The breakthrough came when I stopped reading theory and started shipping tiny models that solved trivial problems. Predicting my own electricity bill. Classifying movie reviews. Rubbish projects, but they taught me the loop.
What trips people up isn't the math. It's the debugging. A model that performs badly gives you almost no information about why. You develop intuition slowly, through repetition and a lot of failure.
What is the difference between ML and AI?
AI is the goal. Machine learning is one method of reaching it.
Early AI systems used hand-coded rules and symbolic logic — an expert system for medical diagnosis, say, with thousands of if-then statements. ML took over because it scales. Rules don't improve when you add more data. Models do.
Worth noting: not all AI is ML. A pathfinding algorithm in a video game is arguably AI and involves no learning whatsoever. But in practice, when people say "AI" today, they almost always mean machine learning.
Where machine learning goes wrong
The failures are more instructive than the successes, so let me be blunt about them.
Models inherit the biases in their training data. If a hiring model is trained on a decade of decisions skewed toward one demographic, it will reproduce that skew — and it will do so with confident-looking numbers. I watched this happen in a small internal project where a model learned to associate a specific zip code with low creditworthiness, which was really just a proxy for something else entirely.
Then there's the deployment problem. A model that works beautifully in testing can degrade quietly in production as the world shifts. User behavior changes, fraud patterns evolve, an upstream data source starts sending nulls. Without monitoring, you won't notice for months.
And the interpretability gap. When a model rejects your loan application, "the algorithm decided" is not an answer anyone should accept. Regulators in several jurisdictions now require a level of explanation that some of the most accurate model types simply cannot provide. There's a real tension between accuracy and accountability, and nobody has resolved it neatly.
None of this makes machine learning a bad tool. It makes it a tool that demands attention after launch, not just during development.
Where to start if you want to learn this
Pick one narrow problem you care about. Not "learn ML" — that's too vague and you'll drown. Something like: can I predict which of my customers will churn next month? Then work backward from the data you need.
Build the ugliest possible version first. Logistic regression, twenty lines of code, no fancy architecture. Get a baseline number. Only then experiment with complexity.
The people who get good at this aren't the ones who read the most. They're the ones who ship the most small, broken things and fix them.
Which raises a question worth sitting with: as these systems quietly make more of the decisions that shape your daily life — what you see, what you're offered, what you're approved for — how much of that do you actually want to understand? The answer used to be optional. It's becoming less so.
