An Introduction to Machine Learning: How Computers Learn from Data

Machine learning is a way to get a computer to do a task by showing it examples instead of writing step-by-step instructions. You hand an algorithm a pile of labeled data — say, 50,000 emails each marked "spam" or "not spam" — and it tunes millions of internal numbers until it can sort a brand-new email it has never seen. Nobody writes the rule "flag anything containing the word 'free'"; the model infers which signals matter directly from the data.

That single shift, from writing rules to learning from examples, is what separates machine learning from ordinary software. This guide walks through how training actually works, the three flavors you will run into, and the mistakes that trip up almost everyone the first time.

The three types you will actually meet#

Nearly every real system falls into one of three categories, and knowing which is which tells you a lot about what a system can and cannot do.

Supervised learning#

This is the workhorse. You give the model inputs paired with correct answers — the "labels" — and it learns to map one to the other. A spam filter learns from emails labeled spam or not-spam; a house-price model learns from listings labeled with their final sale price. Classic supervised algorithms include linear regression, decision trees, random forests, and gradient-boosted trees (the kind powering libraries like XGBoost and LightGBM, which still win a large share of tabular-data competitions on Kaggle). If your problem has clear right answers baked into the training data, it is supervised.

Unsupervised learning#

Here there are no labels at all. You hand the model raw data and ask it to find structure on its own. k-means clustering groups customers into segments; dimensionality-reduction methods like PCA squash hundreds of columns into a handful you can plot. Recommendation engines lean on this idea to notice that people who watch shows A and B also tend to watch C, without anyone ever labeling "these titles are similar."

Reinforcement learning#

The model learns by trial and error against a reward signal. It takes an action, earns points or penalties, and adjusts to collect more reward over time. This is how DeepMind's AlphaGo learned to beat human Go champions, and how robots learn to walk in simulation before touching the real world. It is powerful but data-hungry and finicky, which is why you meet it far more in games and robotics than in everyday apps.

What "training" really does#

Under the hood, training is a search for numbers. Every model has internal settings — called parameters or weights — and training is the process of finding values for them that make the model's guesses match the real answers.

Here is the loop, stripped down:

1. Show an example. Feed in one batch of data, say 64 emails at a time.
2. Make a prediction. The model outputs a guess, like "87% spam."
3. Measure the error. A loss function scores how wrong that guess was against the true label.
4. Adjust. An algorithm called gradient descent nudges every weight a tiny step in the direction that reduces the error. The size of that step is the learning rate.
5. Repeat. One full pass over the dataset is called an epoch, and models often train for dozens or hundreds of epochs.

The "features" are the individual pieces of input the model looks at. For an email, that might be the sender's domain, the number of links, and the ratio of capital letters. Choosing and shaping those features — feature engineering — used to be most of the job in classic machine learning, and it still matters enormously for spreadsheet-style data.

The overfitting trap#

The single biggest failure mode in machine learning is a model that aces its practice test and flunks the real one. This is called overfitting: the model memorizes quirks of the training examples instead of learning the general pattern.

To catch it, practitioners split their data into three parts before training, typically around 70/15/15:

• Training set — what the model learns from.
• Validation set — held back to tune settings and track progress during development.
• Test set — locked away until the very end, used once to estimate real-world performance.

If a model scores 99% on training data but 74% on the test set, it overfit. The usual fixes are more data, a simpler model, or regularization techniques that penalize over-complication. The opposite problem, underfitting, means the model is too simple to capture the pattern at all — like fitting a straight line to an obvious curve. Balancing these two is the bias-variance tradeoff, the central juggling act of the field.

Accuracy alone can also mislead. If only 1% of emails are spam, a lazy model that labels everything "not spam" scores 99% accuracy and catches nothing. That is why people track precision (of the messages flagged, how many were truly spam) and recall (of the actual spam, how much got caught), often combined into a single F1 score.

From spam filters to ChatGPT#

For decades, "machine learning" mostly meant the classic algorithms above running on tidy tables of numbers. What changed in the 2010s was deep learning: neural networks with many stacked layers, trained on huge datasets using GPUs. On the ImageNet benchmark of over 14 million labeled images, deep networks slashed error rates after 2012 and kept improving year over year.

The current wave runs on the transformer, an architecture introduced in Google's 2017 paper "Attention Is All You Need." Transformers underpin large language models such as the GPT and Claude families. They are still doing the same fundamental thing — predicting the most likely next piece of data based on patterns absorbed during training — just at a scale of billions of parameters trained on much of the public internet. That scale is why they feel fluent, and also why they can state falsehoods with total confidence: a plausible-sounding next word is not the same as a true one.

Common mistakes people make about it#

• Assuming confidence means correctness. A model outputting "98%" is reporting a statistical guess, not a verified fact. Check anything that matters.
• Blaming the algorithm for biased output. If a hiring model favors one group, it is usually faithfully copying bias in historical data. The data is the lever, not the math.
• Thinking more data always wins. Ten thousand clean, varied, correctly labeled examples usually beat a million noisy ones. Garbage in, garbage out is literal here.
• Expecting it to work outside its training distribution. A model trained on daytime photos will struggle at night; one trained on formal English will fumble slang. It only knows the patterns it actually saw.

You do not need calculus to work with these ideas. Knowing that a model learns from examples, lives and dies by its data, and produces educated guesses rather than guarantees is enough to use — and question — these systems intelligently.

FAQ#

Do I need to know how to code to understand machine learning?#

No. The core concepts — learning from labeled examples, splitting data, overfitting — are conceptual and require no math beyond arithmetic. You only need Python and a library like scikit-learn if you want to build a model yourself, and even then the hard part is understanding your data, not the syntax.

What is the difference between machine learning and AI?#

Artificial intelligence is the broad goal of getting machines to do things that seem intelligent. Machine learning is one approach to that goal — specifically, learning patterns from data instead of following hand-written rules. Today's headline AI systems, including large language models, are machine learning under the hood.

How much data does a model need?#

It depends entirely on the task. A simple tabular model might learn well from a few thousand rows, while a large language model is trained on hundreds of billions of words. As a rule, the complexity of the problem and the variety of situations you need to cover drive the requirement far more than raw volume alone.

Why do AI models "hallucinate" or make things up?#

Language models are trained to produce statistically plausible text, not to verify facts. When a topic was rare or contradictory in their training data, the most plausible-sounding continuation can simply be wrong. They have no built-in sense of truth, which is why fact-checking their output remains essential.