A fast pass over the ML fundamentals and SageMaker services this track assumes as background and the AIP-C01 track above it never re-teaches.
The words at a glance
The terms nest inside one another, and most confusion comes from treating them as siblings. Artificial intelligence is the outer ring, machine learning sits inside it, deep learning inside that, and generative AI inside that again. Agentic AI is generative AI handed tools and the freedom to use them. Telling them apart is worth a slow read if the nesting is new.
| Term | What it means |
|---|---|
| Artificial intelligence (AI) | The outer ring: any system doing something we would call intelligent, learned or hand-coded |
| Machine learning (ML) | The part of AI that learns behaviour from data instead of being given rules |
| Deep learning | The part of ML built on many-layered neural networks |
| Neural network | Layers of weighted connections, trained by nudging the weights until predictions improve |
| Generative AI (GenAI) | The part of deep learning that produces new content rather than a label or a number |
| Agentic AI | Generative AI given tools, memory, and the autonomy to plan, act, and act again on the result |
| Large language model (LLM) | A very large text model trained on broad text; the usual engine under generative AI |
| Computer vision | ML applied to images and video: detection, classification, recognition |
| Natural language processing (NLP) | ML applied to human language: extraction, sentiment, translation, summarisation |
| Algorithm | The recipe for learning: linear regression, gradient boosting, a transformer |
| Model | The artefact that recipe produces once it has been trained on data |
| Training | The run that turns data plus algorithm into a model |
| Inferencing | Using the finished model to answer new requests; also called inference, and it can be real-time, serverless, asynchronous, or batch |
| Bias | A systematic skew in the data or the model that pushes predictions one way |
| Fairness | Whether that behaviour holds up across the groups of people it affects |
| Fit | How closely the learned behaviour matches the real relationship, from underfitting through to overfitting |
Data types at a glance
| Data type | What it is | What it permits |
|---|---|---|
| Structured | A fixed schema: defined fields, known types | Classic ML on columns; regression, classification, clustering |
| Unstructured | No schema: free text, images, audio, video | Deep learning and foundation models, usually after embedding or feature extraction |
| Tabular | The common structured shape: rows of records, typed columns | The default for traditional ML and for Canvas or Data Wrangler |
| Time-series | Observations stamped in order, where the order carries meaning | Forecasting; split by time and never shuffle, or the model sees its own future |
| Image | Pixels, with meaning in shape and arrangement rather than any column | Computer vision tasks |
| Text | Language, where meaning depends on sequence and context | NLP tasks and anything token-based |
| Labelled | Every example carries the answer alongside it | Supervised learning: regression and classification |
| Unlabelled | Raw examples with no answer attached | Unsupervised learning such as clustering, or self-supervised pre-training |
Fundamentals at a glance
| Thing | What it is | Reach for it when |
|---|---|---|
| Regression | Labelled data, continuous target | Predicting a number: price, demand, a delivery time |
| Classification | Labelled data, categorical target | Predicting a label: fraud or not, which tier |
| Clustering | Unlabelled data, grouping | Finding structure with no target to predict |
| Semi-supervised learning | A small labelled set plus a large unlabelled one | Labels are expensive and scarce, but raw data is plentiful |
| Self-supervised learning | Labels derived from the data itself | Foundation-model pre-training; no human labelling at all |
| Reinforcement learning | A reward signal from an environment | An agent learns by acting and being scored, not from fixed examples |
| RLHF | Human preference rankings train a reward model | Aligning a model’s responses to what people actually prefer |
| Transfer learning | A pre-trained model adapted with a small labelled set | You want a head start rather than training from nothing |
| Overfitting | Train loss falls, validation loss rises | Too much capacity or too few examples for the model to generalise |
| Underfitting | Both losses stay high | Too little capacity, too few epochs, or too low a learning rate |
| Data drift | The input distribution shifts over time | Same relationship between input and target, different inputs arriving |
| Concept drift | The input-to-target relationship changes over time | The same inputs now deserve a different answer |
| Training-serving skew | A pipeline mismatch between training and serving | Degradation shows up immediately, not gradually like the other two |
| Bias and variance | High bias is underfitting, high variance is overfitting | Naming the failure this way makes the responsible-AI consequence visible: either one can land harder on a single demographic group than the aggregate score admits |
| Data collection | Gathering the raw data the model learns from | The first pipeline stage, and the ceiling on everything after it |
| Exploratory data analysis | Looking at distributions, gaps, and outliers before committing | You need to know what the data actually contains |
| Data pre-processing | Cleaning, de-duplicating, filling or dropping missing values, normalising | Raw data is rarely fit to train on as it arrives |
| Feature engineering | Deriving the inputs the model actually learns from | The signal is implied by the raw data rather than sitting in a column |
| Model training | Running the algorithm over prepared data to produce a model | The prepared data is stable enough to be worth the compute |
| Hyperparameter tuning | Searching the settings fixed before training for a better combination | A trained model works but you want more out of the same data |
| Evaluation | Scoring the trained model against data it never saw | Before anyone decides whether to ship it |
| Deployment | Putting the model where requests can reach it | The evaluation cleared whatever bar the business set |
| Monitoring | Watching the live model for drift, quality, and bias | From the moment it serves its first real request |
| MLOps | Running that pipeline the way software gets run: tracked, repeatable, monitored | You want models managed with the same rigour DevOps gives code |
| Experimentation | Tracked, comparable training runs | You need to know which change produced which result |
| Repeatable processes | The same pipeline yields the same model from the same data | A result nobody can reproduce is a result nobody can ship |
| Scalable systems | Pipelines and endpoints that survive more data and more traffic | The prototype worked and real volume is coming |
| Technical debt | Bespoke glue, orphaned notebooks, unowned features | It compounds faster in ML than in ordinary code, because data changes underneath it |
| Production readiness | Monitoring, rollback, ownership, and documentation in place | Before a model carries real decisions, not after |
| Model re-training | Refreshing the model on newer data | Monitoring showed drift, or the world moved on |
Metrics at a glance
| Metric | What it measures | Watch for |
|---|---|---|
| Accuracy | The share of all predictions that were right | It flatters a rare positive class; 99% accuracy on 1% fraud is what you get by predicting “no fraud” every time |
| Precision | Of everything flagged, how much really was | Raise it when a false positive is the expensive error |
| Recall | Of everything that really was, how much got flagged | Raise it when a miss is the expensive error |
| F1 score | The harmonic mean of precision and recall | One number to carry when both errors cost something |
| Cost per user | Inference and infrastructure spend divided by active users | It moves as the feature succeeds, so track it alongside adoption |
| Development costs | People, labelling, and experimentation to get to a first model | Paid once; weigh it against a recurring saving, not a one-off one |
| Customer feedback | Ratings, complaints, support volume, thumbs | It catches the failures the model metrics score as fine |
| Return on investment (ROI) | Benefit minus cost, over cost | The number the business reads, and the one an offline metric never answers on its own |
The SageMaker suite at a glance
Four of these names are maintenance-only. Ground Truth, Augmented AI, Clarify, and Model Monitor moved to maintenance in June 2026 and closed to new customers at the end of July; existing deployments keep running, and the jobs they did are still jobs somebody has to do, so they stay on this sheet as the vocabulary for the work rather than as things to buy. A build starting now labels with its own annotators or a partner workforce, assembles a review gate from Step Functions or SQS behind a reviewer interface it owns, computes bias metrics and SHAP attributions in its own processing job (or an open-source fmeval run, for a foundation model), and puts drift monitoring together from captured inference data, CloudWatch metrics, and a scheduled comparison job. The security and responsible-AI sheet carries the same note.
| Service | Job | Reach for it when |
|---|---|---|
| Ground Truth (maintenance-only) | Labels training data | You need a labelled dataset built before training starts |
| Augmented AI (A2I) (maintenance-only) | Routes production predictions to a human reviewer | A live prediction needs a person to check it before it acts |
| Clarify, pre-training bias (maintenance-only) | Runs over the data before a model exists: class imbalance, difference in proportions of labels | You want to know whether the training set is skewed before spending anything on training |
| Clarify, post-training bias and explainability (maintenance-only) | Runs over the trained model’s predictions, plus SHAP feature attribution | You want to know whether the model’s behaviour is skewed, or which features drove one prediction |
| Model Monitor (maintenance-only) | Watches a live endpoint on four fronts: data quality, model quality, bias drift, and feature attribution drift | You need continuous production monitoring, not a one-off check |
| Model Cards | Human-written documentation: intended use, limits, eval results | You need to record and communicate what a model is for |
| Model Registry | A version catalogue with approval status | You need to gate what gets promoted into a CI/CD pipeline |
| Feature Store | One ingestion, two reads | You need the same features served at millisecond latency and pulled for training history |
| Pipelines | ML CI/CD orchestration | You need to automate the steps from data to deployed model |
| JumpStart | A model hub you deploy onto your own endpoints and instances | You want a pre-built model but need instance choice or your own VPC |
| Canvas | No-code ML | A business user needs to build a model without writing code |
| Data Wrangler | Visual data preparation | You need to clean and transform data without a notebook |
| Trainium | Purpose-built training silicon | You are training a large model and want the cost-efficient chip for it |
| Inferentia | Purpose-built inference silicon | You are serving a large model and want the cost-efficient chip for it |
| Real-time inference | An always-on endpoint | Traffic is steady and needs low, consistent latency |
| Serverless inference | Scales to zero between requests | Traffic is intermittent and cold starts are acceptable |
| Asynchronous inference | A queue in front of the endpoint | Payloads are large or processing is slow, and nobody is waiting live |
| Batch transform | Scores a whole dataset offline, no endpoint | You are scoring data once with no live traffic at all |
Deployment strategies at a glance
| Strategy | Shape | Reach for it when |
|---|---|---|
| Shadow | A copy of live traffic runs the new version with zero user exposure | You want a pure comparison before anyone is at risk |
| Canary | A small percentage of real users hit the new version | You want to expand gradually once the small slice looks healthy |
| Blue/green | Two full parallel environments, one cutover | You want an instant, whole-scale switch and an instant rollback |
| A/B | Traffic is deliberately split to compare outcomes | You are running an experiment, not a rollout |
Decision rules
- If a term is confusing, place it in the nesting: AI contains ML, ML contains deep learning, deep learning contains generative AI, and agentic AI is generative AI plus tools and autonomy. Almost every distractor here treats two rings as rivals.
- If the task has one outcome that is legally or contractually correct every time, write a rule, not a model. Tax bands, eligibility thresholds, and statutory retention periods want deterministic logic; a prediction that is right 99% of the time is wrong 1% of the time on something that had a defined answer.
- If the data is structured and labelled, traditional ML is usually enough; if it is unstructured (text, image, audio), you are into deep learning or a foundation model.
- If the data is time-series, split it by time. Shuffling lets the model train on the future it is meant to predict, and the score will look excellent right up until production.
- If one class is rare, quote precision, recall, or F1 rather than accuracy, and say which error you chose to make cheaper.
- If training and validation error are close but one subgroup scores far worse, that is under-representation in the training data, not overfitting. More data from that group fixes it; regularisation does not.
- If you have hyperparameters (epochs, learning rate, batch size), those are set before training; if you have inference parameters (temperature, top-p, top-k), those are set per request. Confusing the two is a classic distractor.
- Work the ML lifecycle as a loop, not a line: business goal, collect, prepare and explore, engineer features, train, tune, evaluate, deploy, monitor, and back to collect when monitoring finds a gap.
- If you want zero user exposure while comparing a new model, use shadow; if you want to expand gradually into real traffic, use canary; if you want an instant whole-scale switch with an instant rollback, use blue/green; if you are deliberately comparing outcomes rather than rolling something out, that is an A/B test.
- If the target is a number, that is regression; if it is a category, that is classification; if there is no target at all, that is clustering.
- If labels are scarce but raw data is not, use semi-supervised learning rather than waiting for a fully labelled set.
- If you are pre-training a foundation model, the labels come from the data itself; that is self-supervised learning, and nobody hand-labels anything.
- If you want a model to prefer certain responses by human judgement, that is RLHF, and it is a training technique, not an evaluation method.
- If validation loss rises while training loss keeps falling, you are overfitting; cut epochs, add data, or regularise.
- If both losses stay stubbornly high, you are underfitting; add capacity, train longer, or raise the learning rate.
- If a model that was fine yesterday is wrong more often today and the inputs still look the same shape, suspect concept drift before blaming the pipeline.
- If a model is wrong from the day it deployed, suspect training-serving skew, not drift; drift takes time to appear, skew does not.
- If you need training data labelled, that is Ground Truth’s job; if you need a live prediction checked by a person before it acts, that is A2I’s. They sit on opposite sides of deployment, and since both closed to new customers in late July 2026 the split is what carries, whoever builds the workflow.
- If you need to measure bias or explain a prediction, that is Clarify’s job; if you need to watch a live endpoint keep behaving the same way, that is Model Monitor’s. Both are maintenance-only now, so a new build computes the metrics in its own processing job and assembles the monitor from captured inference data, CloudWatch, and a schedule.
- If you need to document what a model is for, write a Model Card; if you need to gate what gets promoted to production, use the Model Registry. Documentation is not a deployment gate.
- If a model needs to serve at millisecond latency and also be pulled for training history, use Feature Store’s online and offline stores from one ingestion.
- If you want a pre-built model but need to pick the instance type or keep it inside your own VPC, use JumpStart; a fully managed API surface gives you neither.
- If a business user needs a model with no code, point them at Canvas, not a notebook.
- If traffic is steady, use a real-time endpoint; if it is intermittent, use serverless and accept the cold starts; if payloads are large or slow, use asynchronous inference; if there is no live traffic at all, use batch transform.
Traps
- Taking accuracy as a comfort number when the positive class is rare. A model that never predicts the rare class can score in the high nineties and catch nothing at all.
- Reading a single aggregate accuracy figure as evidence of fairness. Aggregates hide the group that the model serves badly; only subgroup analysis surfaces it.
- Treating inferencing as one shape. Real-time, serverless, asynchronous, and batch are four answers to the same question, and this scenario’s traffic pattern picks between them.
- Confusing self-supervised learning with unsupervised learning. Self-supervised still trains against a target; the target is just derived automatically from the data, not hand-labelled.
- Treating RLHF as an evaluation technique. It trains a reward model from preference data; it does not measure anything after the fact.
- Assuming drift is always gradual. Training-serving skew is a pipeline bug, not a drift phenomenon, and it shows up on day one.
- Mixing up which drift is which: data drift is the inputs changing shape; concept drift is the correct answer for the same inputs changing. Same symptom, different cause.
- Picking Ground Truth when the question is about a live prediction, or A2I when the question is about building a training set. The clue is always which side of deployment the data sits on.
- Treating a Model Card as something that blocks a release. It documents; the Model Registry’s approval status is what actually gates a pipeline.
- Assuming Clarify and Model Monitor do the same job because both mention bias. Clarify measures it in the data before training and in the model after; Model Monitor watches for it continuously once the model is live.
- Treating Ground Truth, A2I, Clarify, and Model Monitor as services to adopt. All four closed to new customers at the end of July 2026 after moving to maintenance a month earlier. Learn them for the distinctions they name, and expect a fresh build to assemble the same four jobs from primitives it owns.
- Reaching for a real-time endpoint out of habit when traffic is genuinely bursty and idle time is long; that is what serverless is for, cold starts and all.
- Forgetting that batch transform has no persistent endpoint at all; it is not a cheaper real-time option, it is a different shape of job.
- Treating an A/B test as a rollout mechanism. It is an experiment to compare outcomes; shadow, canary, and blue/green are the ways you actually roll something out.
- Reaching for blue/green when the real ask is gradual exposure, or canary when the real ask is an instant whole-scale cutover; the shape of the risk decides which one fits.
Say it in one line
- Labelled and continuous means regression, labelled and categorical means classification, unlabelled means clustering.
- Self-supervised learning derives its own labels from the data; that is how foundation models pre-train.
- RLHF trains a reward model from human preference rankings; it is a training step, not a measurement.
- Overfitting shows as rising validation loss against falling training loss; underfitting shows as both staying high.
- Data drift is the inputs changing, concept drift is the correct answer changing, and training-serving skew is a pipeline bug that bites from day one.
- Ground Truth labels training data; A2I reviews production predictions. Different side of deployment, different job.
- Clarify measures bias and explains predictions; Model Monitor watches a live endpoint keep behaving the same way over time.
- Ground Truth, A2I, Clarify, and Model Monitor are all maintenance-only since June 2026 and closed to new customers from the end of July; the four distinctions still hold, the managed packaging does not.
- Model Cards document; the Model Registry’s approval status gates what actually ships.
- Feature Store serves the same features at millisecond latency online and as training history offline, from one ingestion.
- Pipelines orchestrate ML CI/CD; JumpStart deploys a pre-built model onto your own instances; Canvas is no-code; Data Wrangler is visual prep.
- Trainium trains, Inferentia infers.
- Real-time is always-on, serverless scales to zero with cold starts, asynchronous queues large payloads, and batch transform scores offline with no endpoint at all.
- Hyperparameters are set before training; inference parameters are set per request.
- The ML lifecycle is a loop: goal, collect, prepare, engineer, train, tune, evaluate, deploy, monitor, and back to collect.
- Shadow exposes nobody, canary exposes a slice, blue/green cuts over wholesale, and A/B is an experiment rather than a rollout.
- AI contains ML, ML contains deep learning, deep learning contains generative AI, and agentic AI adds tools and autonomy on top.
- Computer vision reads images, natural language processing (NLP) reads language, and both are applications of ML rather than alternatives to it.
- An algorithm is the recipe, a model is what training produced from it, and inferencing is what the model does afterwards.
- Structured and labelled data suits traditional ML; unstructured data pushes you towards deep learning and foundation models; time-series data has to be split by time.
- Accuracy, precision, recall, and F1 score judge the model; cost per user, development costs, customer feedback, and return on investment (ROI) judge whether it earned its keep.
- MLOps is experimentation, repeatable processes, scalable systems, managed technical debt, production readiness, monitoring, and re-training.
- High bias is underfitting, high variance is overfitting, and either can hurt one demographic group more than the aggregate number shows.
- An aggregate score never demonstrates fairness; subgroup analysis is what turns a suspicion into a finding.