Exam objective 1.2 is all about one skill: looking at a business problem and instantly knowing which type of machine learning algorithm will solve it. This matters because the MLS-C01 exam loves to give you a scenario — 'predict customer churn' or 'detect fraud' — and ask you to pick the right algorithm family, and if you pick wrong, the whole answer collapses. You are learning to be a chef who reads a recipe and knows whether to boil, fry, or bake.
Jump to a section
A simple way to picture Modeling Fundamentals: Algorithms and Problem Types
Have you ever tried to cook a five-course meal for eight people with wildly different dietary needs? That sinking feeling when you realise a single dish just won't work? That is exactly the problem machine learning practitioners face when they pick the wrong algorithm for their problem type. You wouldn't serve a vegan guest a steak, so why would you use a regression algorithm (which predicts a number) when you need to classify an email as spam or not spam?
Let me walk you through my dinner party. You have: a friend who is gluten-intolerant, a lactose-intolerant cousin, a vegan neighbour, and a keto-obsessed uncle. Each person needs a completely different meal. Your job as the host is to match the right dish to the right person — just like the data scientist's job is to match the right algorithm to the right problem. A regression algorithm is like a measuring cup: it tells you "how much" (price, temperature). A classification algorithm is like a party invite list: it tells you "which category" (guest lists the vegan, guest lists the meat-eater). A clustering algorithm is like organising seating by interests: it finds natural groups without labels. And a reinforcement learning algorithm? That is like training a puppy: you reward good behaviour and punish mistakes until the puppy learns the optimal decision.
If you serve the wrong algorithm to your data, you get cold, inedible results — unreliable predictions and a wasted dinner (and a wasted cloud bill). The skill is knowing which meal your data is hungry for.
Machine learning is not magic — it is pattern-matching at scale. Every algorithm is a tool, and like any toolkit, you need the right tool for the right job. The MLS-C01 exam tests whether you can look at a business problem and say, 'That needs a classification algorithm, not a regression one.'
Let us break down the main problem types. The first, and most common, is Supervised Learning. In supervised learning, you have a dataset with both inputs and the correct answers. Think of it as studying for a test with an answer key: you learn from labelled examples, so you can predict the label on new, unseen data. Supervised learning splits into two sub-types: Classification and Regression.
Classification is when the output is a category. Is this email spam or not spam? Is this transaction fraudulent or legitimate? Is this image a cat or a dog? The algorithm predicts a class label. Common classification algorithms include Logistic Regression (despite the name, it is for classification), Decision Trees, Random Forests, Support Vector Machines (SVM), and for more complex tasks, Neural Networks.
Regression is when the output is a continuous number. Predicting house prices, forecasting temperature, estimating a customer's lifetime value. The algorithm outputs a real number. Common regression algorithms include Linear Regression, Polynomial Regression, Decision Tree Regressor, and Random Forest Regressor.
The second major family is Unsupervised Learning. Here, you have only input data, no labels. You are asking the algorithm to find hidden structure or groupings on its own. The most common unsupervised task is Clustering, where the algorithm groups similar data points together. Think of customer segmentation: which customers behave similarly? The most famous clustering algorithm is K-Means. Another is Dimensionality Reduction, where you reduce the number of features (columns) while preserving as much information as possible. Principal Component Analysis (PCA) is the classic example. Use unsupervised learning when you want to explore the data structure or label data is too expensive to obtain.
The third family is Reinforcement Learning. An agent learns by interacting with an environment, taking actions, and receiving rewards or penalties. The goal is to maximise cumulative reward over time. This is not about static data; it is about sequential decision-making. Classic algorithms include Q-Learning and Deep Q-Networks (DQN). Use this for robotics, game playing, or resource allocation problems where the optimal strategy emerges through trial and error.
There is also a special case called Semi-Supervised Learning, where you have a small amount of labelled data and a large amount of unlabelled data. The algorithm uses the labelled data to guide the grouping of the unlabelled data. This is useful when labelling is expensive but you have cheap, abundant unlabelled data.
Now, why does AWS care about this? Because Amazon SageMaker (AWS's machine learning platform) offers built-in algorithms optimised for each problem type. For example, Linear Learner can handle both classification and regression. XGBoost is a powerful tree-based algorithm for structured data. BlazingText handles text classification. The exam wants you to know which algorithm fits which problem type at a high level.
Key principle: Always match the algorithm family to the output type. If the output is a category → classification. If the output is a number → regression. If there is no output label → unsupervised. If the agent learns by doing → reinforcement learning. Get this wrong, and your model will either fail or produce nonsense.
Identify the Output Type
Ask: 'What is the target variable? Is it a category (spam/not spam) or a continuous number (price)?' This determines whether you need a classification or regression algorithm. If there is no target variable at all, you are in unsupervised territory.
Check for Labelled Data
Do you have a training dataset with correct answers? Yes → supervised learning. No → unsupervised or semi-supervised. This step filters out 90% of wrong choices. If you have labels, you cannot use K-Means (clustering) for a prediction task.
Consider the Data Type (tabular, text, image)
For tabular data (spreadsheets), XGBoost or Linear Regression are strong choices. For text, BlazingText or a neural network with embeddings works. For images, Convolutional Neural Networks (CNNs) are standard. The data type heavily influences the specific algorithm you select within the problem type family.
Select the Algorithm Family
Based on output type and data type, pick the algorithm family: classification → Logistic Regression, Decision Tree, Random Forest, SVM; regression → Linear Regression, Decision Tree Regressor; clustering → K-Means. This is where you apply the mapping the exam tests.
Evaluate and Iterate
Train the model, then evaluate using the right metric: accuracy, precision, recall for classification; RMSE or MAE for regression; silhouette score for clustering. If performance is poor, revisit the algorithm choice or tune hyperparameters. Never skip evaluation — it validates your initial decision.
Imagine you work at a mid-sized e-commerce company called 'ShopStream'. Your manager comes to you with a problem: 'Our customer churn rate is spiking. We need to predict which customers are about to leave, so we can send them a retention coupon before they cancel.' This is a classic classification problem. The output is binary: churn (yes) or no churn (no). You would reach for Logistic Regression, Random Forest, or XGBoost from SageMaker's built-in algorithms.
But the data is messy. You have customer ID, purchase history, days since last visit, support ticket count, and customer age. Some features are numbers (purchase history), some are categories (customer region). You need to preprocess the data. You split it into training and testing sets. You train the model on historical labelled data (customers who churned vs those who did not). The model learns patterns: 'Customers who have not bought in 90 days and filed a support complaint are 80% likely to churn.' You deploy the model as an endpoint in SageMaker. Every night, the model scores your entire customer base and pushes the at-risk customers to a list. Your marketing team then emails them a 20% off coupon. Churn drops by 15%.
Now consider a different scenario: your boss asks you to segment customers for a targeted marketing campaign. 'We want to find natural groups among our shoppers — bargain hunters, luxury buyers, one-time deal seekers.' Here, there is no label. You have customer transaction data, but no one has labelled groups. This is an unsupervised clustering problem. You fire up K-Means or a Gaussian Mixture Model in SageMaker. You run the algorithm, and it identifies three clusters. You name them 'Budget Shoppers', 'Premium Spenders', and 'Seasonal Buyers'. Now your marketing team can craft different ads for each group.
A third scenario: your logistics team wants to automate robot picking in the warehouse. The robot must decide which shelf to move to and which item to grab. This is reinforcement learning. You model the warehouse as an environment, the robot's actions as moving left/right/grab, and the reward as successfully placing the item in the shipping bin. The robot practises in a simulator (powered by AWS RoboMaker) and learns an optimal policy. It eventually outperforms a human picker.
What does a real IT professional do with this? They spend the first meeting asking: 'What is the output? A category or a number? Do we have labels?' That single question determines 80% of the solution architecture. They then pick the algorithm family, select the specific SageMaker built-in algorithm, set the hyperparameters (like number of trees in a random forest), split data, train, and evaluate using metrics like accuracy (classification) or RMSE (Regression, Root Mean Squared Error). They never, ever start coding before they know the problem type.
The MLS-C01 exam tests your ability to map a business scenario to the correct algorithm family. Expect scenario-based questions where you read a short paragraph and select the right algorithm or problem type. The exam does not ask you to code an algorithm; it asks you to know what each algorithm does and when to use it.
Here are the exact concepts they love to test:
Distinguishing Classification vs Regression: Trap questions will describe a numeric output but word it as a category (e.g., 'predict the price category (low, medium, high)' — this is still classification, not regression, because the output is discrete categories).
When to use Unsupervised Learning: If the question mentions 'no labelled data' or 'discover hidden groups', answer clustering. Common algorithms: K-Means, DBSCAN, Hierarchical Clustering.
Reinforcement Learning scenarios: Usually involve an 'agent', 'environment', 'reward', 'action'. Common traps: confusing reinforcement learning with supervised learning when the problem involves sequential decisions.
Which algorithm for text? BlazingText for text classification (supervised) or Word2Vec (unsupervised embeddings).
Which algorithm for image classification? They might ask about algorithms built into SageMaker or generally known ones like Convolutional Neural Networks (CNNs).
Ensemble methods: Random Forest (bagging) and XGBoost (boosting) — know they reduce overfitting and improve accuracy.
Bias-variance trade-off: Simple models (like Linear Regression) have high bias but low variance; complex models (like deep neural nets) have low bias but high variance.
If the dataset is very large, which algorithm scales? XGBoost can be slow on massive data, while Linear Learner or built-in Deep Learning algorithms can handle larger datasets on SageMaker.
Trap patterns to watch: - 'The output is a dollar amount' — this is regression. But if the question says 'predict whether the price will be above or below a threshold', that is classification. - 'Group customers' sounds like clustering, but if they provide labelled groups in the training data, it is supervised classification. - 'Reinforcement learning' is always about maximising a reward, never about predicting from static historical data.
Key definitions to memorise:
Supervised learning: labelled data, predict label.
Unsupervised learning: unlabelled data, find patterns.
Reinforcement learning: interaction, reward maximisation.
Classification: discrete outputs (spam/not spam).
Regression: continuous outputs (price).
Clustering: groups without labels.
Overfitting: model memorises noise, performs poorly on new data.
Underfitting: model too simple, misses patterns.
Expect 3-5 exam questions on objective 1.2 directly. They are usually straightforward if you have internalised the mapping: 'Scenario → Problem Type → Algorithm Family.'
Supervised learning requires labelled data and is used for prediction (classification or regression).
Unsupervised learning finds hidden patterns in unlabelled data, typically through clustering or dimensionality reduction.
Reinforcement learning involves an agent learning optimal actions through rewards in an environment, not from static labels.
The output type (category vs number) is the single most important factor in choosing between classification and regression algorithms.
SageMaker's built-in algorithms (Linear Learner, XGBoost, BlazingText) are optimised for specific problem types and should be matched accordingly.
Misunderstanding the problem type at the start leads to invalid models no matter how well you tune hyperparameters.
Ensemble methods like Random Forest and XGBoost combine multiple weak learners to improve accuracy and reduce overfitting.
Bias-variance trade-off: simple models underfit (high bias), complex models overfit (high variance) — find the sweet spot.
These come up on the exam all the time. Here's how to tell them apart.
Classification
Output is a discrete category (e.g., 'yes'/'no', 'cat'/'dog').
Uses metrics like accuracy, precision, recall, F1-score.
Common algorithms: Logistic Regression, Random Forest Classifier, SVM.
Regression
Output is a continuous real number (e.g., price 150.75).
Uses metrics like RMSE, MAE, R-squared.
Common algorithms: Linear Regression, Decision Tree Regressor, Random Forest Regressor.
Supervised Learning
Training data includes labelled target variable (answers).
Goal is to predict the label for new inputs.
Common tasks: classification and regression.
Unsupervised Learning
Training data has no labels; only input features.
Goal is to discover hidden patterns or groupings.
Common tasks: clustering and dimensionality reduction.
K-Means Clustering
Requires you to specify the number of clusters (K) upfront.
Assumes clusters are spherical and roughly equal in size.
Sensitive to outliers; forced to assign every point to a cluster.
DBSCAN Clustering
Does not require number of clusters — finds them based on density.
Can find arbitrarily shaped clusters and handle noise.
Robust to outliers; points in low-density regions are labelled as noise.
Logistic Regression
Used for binary classification (output is probability between 0 and 1).
Uses sigmoid function to squash output to probability range.
Evaluation metric: log loss or accuracy.
Linear Regression
Used for regression (output is an unbounded continuous number).
No activation function — fits a straight line to data.
Evaluation metric: RMSE or R-squared.
Mistake
Regression and classification are essentially the same thing because both predict something.
Correct
Regression predicts continuous numbers (e.g., price 150.75), while classification predicts discrete categories (e.g., 'low', 'medium', 'high'). They use different algorithms and different evaluation metrics (RMSE vs accuracy).
Beginners see 'predict' and assume one-size-fits-all, not realising the output type dictates the entire algorithm choice.
Mistake
Unsupervised learning is useless because there are no labels to learn from.
Correct
Unsupervised learning is powerful for discovering hidden patterns, customer segments, or anomalies when labels do not exist or are too expensive to create. It is used heavily in recommendation systems and fraud detection.
People undervalue pattern discovery because they fixate on prediction tasks that require labels.
Mistake
You can use the same algorithm for any problem if you just tune it enough.
Correct
Algorithms are fundamentally designed for specific output types. Using a regression algorithm for classification (e.g. treating categories as numbers) will produce meaningless results. The algorithm family must match the problem type.
Many beginners think algorithms are general-purpose 'magic boxes' and ignore the mathematical constraints of the output format.
Mistake
Reinforcement learning is just a fancy name for supervised learning with feedback.
Correct
Reinforcement learning does not use a fixed dataset with pre-labelled answers. The agent learns through trial and error in an environment, receiving delayed rewards, not immediate supervision. It is fundamentally different from supervised learning.
The term 'learning from feedback' sounds similar to supervised learning, so newcomers conflate the two.
Mistake
If you have a large dataset, always use a neural network as it is the most powerful algorithm.
Correct
Neural networks are powerful but not always optimal. For structured data (tabular), tree-based algorithms like XGBoost often outperform neural networks. The best algorithm depends on data type, size, and problem type.
The hype around deep learning leads people to overapply it when simpler algorithms would be more effective.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
Supervised learning learns from labelled examples (like studying with answer keys). Unsupervised learning finds patterns in data without any answers given (like organising a messy room by grouping similar items together).
Use reinforcement learning when you have an agent that must make sequences of decisions in an environment, and you can define a reward signal (like training a robot to walk). Use supervised learning when you have a static dataset with labels, and you want to predict a single output per input.
Technically you can force it, but it is not recommended. Linear regression outputs continuous values, not probabilities between 0 and 1, so you would need to threshold the output arbitrarily. Logistic regression is designed specifically for binary classification and gives proper probability outputs.
DBSCAN (Density-Based Spatial Clustering of Applications with Noise) is a good choice because it does not require you to specify the number of clusters in advance — it finds clusters based on density. K-Means, on the other hand, requires you to specify K (the number of clusters).
Both. You need to know the major algorithm names (Linear Regression, Logistic Regression, K-Means, XGBoost, Random Forest, etc.) and which problem type they solve. Expect scenario questions where you pick the specific algorithm, not just the family.
The model will be unable to output a continuous number. It will predict discrete categories, which means you lose the granularity of the numeric target. For example, predicting house price categories (cheap, expensive) instead of the exact price gives you far less useful information.
You've finished Modeling Fundamentals: Algorithms and Problem Types. Continue through the MLS-C01 study guide to build a complete picture of the exam.
Done with this chapter?