What Is Machine Learning? How Computers Learn Patterns From Data
Learn what machine learning is, how models are trained on data, how it differs from traditional programming, and why it is a core part of modern AI systems.
Traditional programming usually begins with rules.
A developer decides what should happen, writes those instructions into software, and gives the program some data to process.
If the rules are clear enough, this works extremely well. But many problems are difficult to describe as a complete set of instructions. What exact rules distinguish every fraudulent payment from a legitimate one? How do you describe every possible photograph of a dog? Which combination of customer behaviors means someone is likely to cancel a subscription next month?
Machine learning changes the approach.
Instead of manually defining every rule, we give a computer data and use an algorithm to train a model. The model adjusts its internal parameters until it learns relationships that are useful for making predictions, classifications, or other outputs.
At a high level:
Training data
↓
Learning algorithm
↓
Trained model
↓
New data
↓
Prediction / classification
Machine learning is a major branch of artificial intelligence, but the two terms are not interchangeable. AI is the broader field of building systems capable of tasks associated with intelligence. Machine learning is one of the main ways we build those systems today, which is why what artificial intelligence is is the broader companion topic.
The central idea is simple: instead of programming every answer directly, train a model to learn useful patterns from examples.
Learning From Data Instead of Writing Every Rule
Imagine building software to detect fraudulent credit-card transactions.
A traditional rule-based system might contain instructions such as:
IF transaction > $5,000
AND country != customer's normal country
THEN flag transaction
That rule may catch some fraud, but real fraud is rarely that predictable. A $20 transaction could be fraudulent, while a $10,000 purchase could be perfectly legitimate.
You could keep adding rules, but eventually you are trying to manually describe thousands of interacting signals: transaction amount, merchant, location, device, time, previous purchases, account age, recent activity, and much more.
Machine learning approaches the problem differently.
Give a learning algorithm historical transaction data containing examples of legitimate and fraudulent activity, and it can search for statistical relationships between the available information and the outcome.
The resulting model might discover that no individual signal is particularly suspicious, but a particular combination of device change, transaction timing, merchant type, and account behavior strongly correlates with fraud.
A programmer did not need to write that exact combination as a rule. The model learned the relationship from data.
That ability to learn complicated relationships is what makes machine learning useful for problems where the rules exist but are too numerous, subtle, or variable to express manually.
Training Data Provides the Examples
Machine learning begins with training data.
The exact form of that data depends on the problem. A fraud model may learn from transaction records. An image-recognition model may learn from photographs. A forecasting system may learn from historical sales, while a language model can learn statistical relationships from enormous collections of text and other data.
For many machine-learning problems, it is useful to think about the data in terms of features and labels.
Features are the pieces of information available to the model.
For a house-price model, features might include:
- floor area;
- number of bedrooms;
- location;
- property age;
- lot size.
The label is the outcome the model is being trained to predict. In this case, that might be the sale price.
So a training example could conceptually look like:
Features Label
3 bedrooms
180 m²
Location: A
12 years old ───────► $620,000
The learning algorithm processes many such examples and adjusts the model so that its predictions become better aligned with the known outcomes.
Not every machine-learning method uses labelled data, which becomes important when we get to unsupervised learning. But the feature-and-label structure is a good way to understand many common predictive systems.
The Algorithm Trains the Model
The words algorithm and model are often mixed together, but they are not quite the same thing, a distinction that is also spelled out in Google’s machine learning glossary.
The algorithm describes the learning process. The model is the learned mathematical structure produced through that process.
A simplified training loop looks like this:
Training example
↓
Model makes prediction
↓
Compare with expected result
↓
Calculate error
↓
Adjust model parameters
↓
Repeat
Those adjustable values are called parameters.
The exact meaning of a parameter depends on the type of model. A simple linear model may have only a relatively small number of weights. A modern neural network can contain millions or billions of parameters.
Training attempts to find parameter values that make the model perform well according to a chosen objective.
For a simple regression problem, that may mean reducing the difference between predicted and actual values. For classification, it may mean increasing the probability assigned to the correct class.
After many examples and parameter updates, the model hopefully learns relationships that extend beyond the individual records it saw during training.
That last part is critical.
The goal is not to memorize the training dataset.
The goal is to generalize.
A Good Model Must Work on Data It Has Never Seen
Suppose a student memorizes the exact answers to a practice exam.
If the real exam contains the same questions, the student appears brilliant. Change the questions, and suddenly the apparent understanding disappears.
Machine-learning models can suffer from a similar problem.
A model can become too closely fitted to its training data, learning details and noise that do not generalize to new examples. This is called overfitting.
That is why model performance needs to be evaluated using data that was not simply used to train it, the same basic verification instinct behind what a mock server is and other ways of testing behavior outside the happy path.
A typical workflow separates available data into different roles, commonly including training and test data, with validation data or cross-validation often used during model development.
The important distinction is:
Training data → learn the model
Unseen data → test whether learning generalizes
If a fraud model performs brilliantly on historical records it already learned from but badly on new transactions, it is not a useful fraud detector.
Testing on unseen data gives a more realistic estimate of how the model might behave when deployed.
It also helps expose one of the biggest traps in machine learning: a model can learn the training data extremely well without learning the underlying problem particularly well.
Performance Depends on What You Measure
There is no single universal score for a good machine-learning model.
For some classification problems, accuracy is useful: what percentage of predictions were correct?
But accuracy can also be dangerously misleading.
Imagine 10,000 transactions where only 50 are fraudulent. A model that predicts “not fraud” for every transaction would be correct 99.5% of the time.
It would also catch absolutely no fraud.
For that reason, classification systems may be evaluated using measures such as precision, recall, F1 score, or other metrics appropriate to the problem. Forecasting and regression systems use different error measurements again, and scikit-learn’s model evaluation guide is a good primary reference for that toolbox.
The right metric depends on the consequences of different mistakes.
In medical screening, missing a genuine condition may carry a different cost from sending someone for an unnecessary follow-up test. In fraud detection, blocking legitimate customers creates a different problem from allowing fraudulent transactions through.
Model evaluation is therefore not only a mathematical question.
Someone has to decide which errors matter most.
Inference Is When the Trained Model Meets New Data
Once a model has been trained and evaluated, it can be used on new inputs.
This stage is called inference.
For example:
TRAINING
Historical transactions
↓
Learning algorithm
↓
Fraud model
INFERENCE
New transaction
↓
Fraud model
↓
Fraud probability
Training might happen periodically using large datasets and significant computing resources. Inference can happen every time a real user or production system needs a prediction.
An image-recognition model performs inference when it receives a new photograph and classifies what it sees. A recommendation model performs inference when it ranks products for a shopper. A forecasting model performs inference when it estimates next month’s demand.
This separation between training and inference is fundamental to modern machine learning.
Training is where the model learns. Inference is where the learned model is used.
Better Machine Learning Usually Means More Than Choosing a Better Algorithm
When a model performs poorly, it is tempting to immediately replace the algorithm with something more sophisticated.
Sometimes that helps. Often the bigger problem is elsewhere, especially if the data pipeline itself is noisy or inconsistent in ways familiar from JSON Schema versus TypeScript types and other validation problems.
The training data may be inaccurate, incomplete, biased, outdated, or poorly representative of the environment where the model is being deployed. The available features may not contain enough useful information. Labels may be inconsistent, or the chosen performance metric may reward the wrong behavior.
Improvement is therefore an iterative process:
collect data → train → evaluate → inspect errors → improve data/features/training → retrain
Suppose a model recognizes daytime road scenes extremely well but fails at night. Making the model larger may help, but the obvious question is whether its training data contained enough representative nighttime examples.
This is why data quality matters so much in machine learning.
A sophisticated algorithm cannot reliably learn information that the training process never provides.
Supervised Learning Learns From Labelled Examples
One of the major categories of machine learning is supervised learning.
Here, training examples include the outcome the model is expected to learn.
You might provide thousands of emails labelled:
Email A → spam
Email B → not spam
Email C → not spam
Email D → spam
The model learns relationships between the email data and those labels so it can classify future emails it has not seen before.
Supervised learning is commonly used for classification and regression, the two task families introduced in Google’s supervised learning crash course.
Classification predicts categories:
- fraud or legitimate;
- spam or not spam;
- defective or acceptable;
- customer likely to churn or stay.
Regression predicts numerical values:
- house price;
- future demand;
- delivery time;
- energy consumption.
The defining feature is not the particular algorithm. It is that the training process has known target outputs available to learn from.
That can make supervised learning powerful, but obtaining reliable labels can be expensive. Someone or some process has to establish what the correct answers actually are.
Unsupervised Learning Looks for Structure Without Labels
Sometimes there is plenty of data but no labelled outcome.
That is where unsupervised learning becomes useful.
Instead of being told the correct category for each example, the system attempts to identify useful structure in the data itself.
A common example is clustering.
Suppose a business has information about customer behavior but has never formally classified its customers into groups. An unsupervised algorithm might identify clusters with different purchasing patterns.
Perhaps one group buys frequently but spends relatively little per order, while another purchases rarely but spends much more.
The algorithm was not necessarily told:
Find our high-value occasional customers.
It found statistical structure, and humans then interpret what that structure means.
Unsupervised techniques can also help with dimensionality reduction, anomaly exploration, and other problems where useful patterns need to be discovered without a predefined label for every example.
The important distinction is:
Supervised learning asks the model to learn a relationship to known answers. Unsupervised learning asks it to find structure without those answers being supplied.
Reinforcement Learning Learns From Rewards and Penalties
Reinforcement learning approaches learning differently again.
Instead of training from a straightforward dataset of labelled examples, an agent interacts with an environment, takes actions, and receives rewards or penalties based on what happens.
The goal is to learn a strategy, or policy, that produces good long-term outcomes.
The loop looks roughly like:
Environment
↓
Current state
↓
Agent chooses action
↓
Environment changes
↓
Reward / penalty
↓
Agent improves its policy
This creates an important complication: the best immediate reward may not produce the best long-term result.
A game-playing system may need to sacrifice something now to improve its chance of winning later. A robot may need to take several intermediate actions before reaching its goal.
Reinforcement learning has been used in game playing, robotics, control systems, resource optimization, and parts of modern AI training, with the Sutton and Barto reinforcement learning book remaining one of the standard references.
The difficult part is often defining the reward.
If you reward the wrong behavior, the system may become very good at optimizing something you never actually wanted.
That is a recurring theme in machine learning: models learn according to the objective they are given, not according to an unstated human intention behind it.
Deep Learning Uses Neural Networks at Scale
Deep learning is a branch of machine learning based on multilayer neural networks.
Artificial neural networks contain interconnected computational units organized into layers. During training, the network’s parameters are adjusted so that it becomes better at transforming inputs into useful outputs.
The word neural comes from loose inspiration from biological neurons, but these systems should not be mistaken for digital replicas of the human brain.
Their importance comes from what they can learn.
Earlier machine-learning systems often depended heavily on humans designing useful features. Deep neural networks can learn complex representations directly from data, which has made them especially powerful for images, speech, language, and other high-dimensional information.
This helped drive major improvements in image recognition and speech recognition. Instead of developers manually specifying every visual feature that distinguishes a bicycle from a motorcycle, a sufficiently trained neural network can learn useful visual representations from examples.
Deep learning is also one of the foundations of modern generative AI, which is part of why what Python is now overlaps so heavily with AI workflows.
But deep learning is not automatically the right answer to every machine-learning problem. For smaller structured datasets, simpler models can be cheaper, faster, easier to explain, and just as effective.
The goal is to solve the problem, not to use the most complicated model available.
Machine Learning Is Already Embedded in Everyday Systems
Much of machine learning is less visible than generative AI.
Recommendation systems use behavioral and contextual data to predict which products, films, songs, posts, or other items a person may find relevant. The system does not need to understand someone’s preferences exactly as another person would; it needs to find patterns that help rank useful candidates.
Image recognition models can classify photographs, detect objects, inspect manufactured products, analyze medical images, and help software interpret visual environments. Speech recognition models turn audio into text, supporting transcription, accessibility tools, call-center systems, and voice interfaces.
In fraud detection, models evaluate transaction patterns and produce classifications or risk scores. Forecasting systems learn from historical data to estimate future demand, sales, traffic, energy consumption, or other quantities.
These applications look very different from the outside, but underneath they share the same broad structure: historical information is used to learn a model, and that model is applied to new information.
Generative AI Is Machine Learning Too
Generative AI can feel fundamentally different because instead of returning a category or numerical prediction, it can generate paragraphs, images, code, audio, or video.
Underneath, however, modern generative AI is deeply connected to machine learning and neural networks.
A large language model, for example, is trained on enormous amounts of data and learns statistical relationships between tokens and their surrounding context. Its parameters are adjusted during training, just as parameters are adjusted in other machine-learning systems, although the scale and architecture are much larger, an architecture family surveyed in the original Transformer paper.
During inference, the model uses what it has learned to generate an output in response to new input.
So the progression is roughly:
Artificial intelligence → machine learning → deep learning → neural networks → modern generative AI
That does not mean every AI system belongs neatly at the end of that chain, nor does it mean all machine learning is generative AI.
A churn model predicting whether a customer will leave is machine learning. A fraud classifier is machine learning. A recommendation engine may use machine learning. None of them needs to generate a paragraph or an image.
Generative AI is a particularly visible application of machine learning, not a replacement for the rest of the field.
The Model Learns Patterns, Not Guaranteed Truth
There is one final distinction that matters across almost every machine-learning application.
A model learns relationships in data.
Those relationships may be extremely useful, but they are not automatically causal, fair, permanent, or correct.
A model may discover that two variables strongly correlate without understanding why. It may learn historical bias contained in its training data. It may perform poorly when the real world changes after deployment, a problem often described as data or concept drift.
Even a model with 95% accuracy is still wrong on some inputs.
That is why production machine learning cannot stop at:
train model → deploy model → finished
Models need monitoring. Their performance needs to be checked against new data, failures need to be investigated, and retraining may become necessary as conditions change.
For consequential decisions, human oversight and ordinary software controls may still need to surround the model.
Machine learning is powerful precisely because we do not have to manually specify every relationship it uses. That same property means we need to be careful about which relationships it learned, whether they still hold, and what happens when they do not.
Machine learning is best understood as a way of turning data into a model that can generalize to new situations. Training teaches the model by adjusting its parameters, testing checks whether those learned patterns work beyond the training examples, and inference applies the resulting model to new data. The algorithms can be sophisticated, but the real measure of success is much simpler: whether the model learned something that remains useful when it meets the real world.