MLS-C01 Exam Cheat Sheet

Last thing to read before the exam. Dense tables, no prose.

Algorithm Quick Reference — All 17+ Built-In

Exam tip — “tabular data with no info on structure” → XGBoost first. Images → Image Classification or Object Detection. Streaming anomaly → RCF.

Metric Quick Reference

Classification Metrics

Accuracy is USELESS for imbalanced data. Always flag this on exam.

Regression Metrics

Other Metrics

Key Formulas

Classification

$$\text{Precision} = \frac{TP}{TP+FP} \qquad \text{Recall} = \frac{TP}{TP+FN}$$

$$F1 = \frac{2 \cdot \text{Precision} \cdot \text{Recall}}{\text{Precision} + \text{Recall}} = \frac{2TP}{2TP+FP+FN}$$

$$F_\beta = (1+\beta^2)\frac{P \cdot R}{\beta^2 P + R}$$

Regression

$$MSE = \frac{1}{n}\sum_{i=1}^n (y_i - \hat{y}_i)^2 \qquad RMSE = \sqrt{MSE}$$

$$MAE = \frac{1}{n}\sum_{i=1}^n |y_i - \hat{y}_i| \qquad R^2 = 1 - \frac{\sum(y_i-\hat{y}_i)^2}{\sum(y_i-\bar{y})^2}$$

Gradient Descent

$$\theta := \theta - \alpha \nabla_\theta J(\theta)$$

Regularization

$$L1 \text{ (Lasso)}: J + \lambda\sum|\theta_j| \qquad L2 \text{ (Ridge)}: J + \lambda\sum\theta_j^2$$

$$\text{Elastic Net}: J + \lambda_1\sum|\theta_j| + \lambda_2\sum\theta_j^2$$

Decision Trees

$$\text{Gini} = 1 - \sum_{i=1}^c p_i^2 \qquad \text{Entropy} = -\sum_{i=1}^c p_i \log_2 p_i$$

$$\text{Information Gain} = H(\text{parent}) - \sum_k \frac{|S_k|}{|S|} H(S_k)$$

Probability

$$P(A|B) = \frac{P(B|A) \cdot P(A)}{P(B)}$$

Service Quick Reference — “When to Use What”

Data Storage

Streaming & Ingestion

ETL & Processing

AI/ML Managed Services

SageMaker Deployment Modes

SageMaker Architecture

┌─────────────────────────────────────────────────────────────┐
│                    SAGEMAKER ECOSYSTEM                       │
│                                                             │
│  ┌──────────┐   ┌──────────┐   ┌──────────┐               │
│  │   Data   │──▶│ Feature  │──▶│ Training │               │
│  │  Sources │   │  Store   │   │   Job    │               │
│  └──────────┘   └──────────┘   └──────────┘               │
│       │                              │                      │
│       │         ┌────────────────────┘                      │
│       │         ▼                                           │
│  ┌──────────┐   ┌──────────┐   ┌──────────┐               │
│  │  S3 /    │   │  Model   │──▶│  Model   │               │
│  │  Ground  │   │ Registry │   │ Monitor  │               │
│  │  Truth   │   └──────────┘   └──────────┘               │
│  └──────────┘        │                                      │
│                       ▼                                      │
│              ┌─────────────────────────────┐               │
│              │     DEPLOYMENT OPTIONS       │               │
│              │ ┌──────┐ ┌──────┐ ┌──────┐ │               │
│              │ │ RT   │ │Batch │ │Async │ │               │
│              │ │Endpt │ │Trans │ │Endpt │ │               │
│              │ └──────┘ └──────┘ └──────┘ │               │
│              └─────────────────────────────┘               │
│                                                             │
│  ┌──────────────────────────────────────────────────────┐  │
│  │    TOOLS: Studio | Pipelines | Experiments | Clarify │  │
│  └──────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

Instance Type Selection

/opt/ml/ Directory (Custom Containers)

/opt/ml/
├── input/
│   ├── config/          ← hyperparameters.json, resourceConfig.json
│   └── data/
│       └── {channel}/   ← training data from S3
├── model/               ← save model artifacts HERE
├── output/
│   └── failure          ← write failure reason here on error
└── code/                ← your training script (if using Script Mode)

Data Format Decision Tree

What is your data?
│
├─ Tabular data
│   ├─ Need fast SageMaker training?  → RecordIO (protobuf) + Pipe mode
│   ├─ XGBoost?                       → CSV or libsvm
│   └─ General purpose?               → CSV (simplest)
│
├─ Image data
│   ├─ SageMaker built-in algo?       → RecordIO + augmented manifest
│   └─ Custom model?                  → Raw files in S3
│
├─ Text data
│   ├─ BlazingText?                   → One sentence per line, space-delimited
│   ├─ Seq2Seq?                       → Tokenized integer sequences
│   └─ General NLP?                   → JSON Lines / CSV
│
└─ Time series
    ├─ DeepAR?                         → JSON Lines (target + timestamp)
    └─ Forecast service?               → CSV or Parquet

RecordIO + Pipe mode = fastest SageMaker training (streams from S3, no copy to disk)

Overfitting vs Underfitting Quick Card

Feature Engineering Quick Card

Numerical Features

• Scale: StandardScaler (mean=0, std=1) for linear/neural models; MinMaxScaler (0-1) for bounded
• Log transform: $\log(x+1)$ for skewed/long-tail distributions
• Binning: Convert continuous → ordinal buckets (age groups)
• Polynomial: $x^2, x_1 x_2$ to capture non-linear relationships
• Clipping: Remove/cap extreme outliers before scaling

Categorical Features

• Label encoding: ordinal categories (low/med/high → 0/1/2)
• One-hot encoding: nominal categories, low cardinality (< ~20 values)
• Target encoding: high cardinality, replaces category with mean(target) — risk of leakage
• Embedding: high cardinality in deep learning (entity embeddings)

Text Features

• BoW / TF-IDF: sparse bag of words, good for linear models
• Word2Vec / FastText: dense embeddings, captures semantics
• BERT / Transformers: contextual embeddings, state-of-the-art
• n-grams: capture phrases, increase vocabulary size

Time Series Features

• Lag features: $x_{t-1}, x_{t-7}$ (yesterday, last week)
• Rolling statistics: rolling mean, rolling std, rolling max
• Decomposition: trend + seasonality + residual
• Differencing: $x_t - x_{t-1}$ to remove trend, stationarity

Missing Data Strategies

Security Quick Card

Encryption

Network

Access Control

Monitoring

Cost Optimization Quick Card

Training

Inference

Storage

The “X vs Y” Quick Reference

Data Pipeline Architecture Patterns

Batch ML Pipeline:
┌──────┐    ┌──────┐    ┌──────┐    ┌──────┐    ┌──────┐
│  S3  │───▶│ Glue │───▶│  S3  │───▶│  SM  │───▶│  S3  │
│ Raw  │    │ ETL  │    │Clean │    │Train │    │Model │
└──────┘    └──────┘    └──────┘    └──────┘    └──────┘

Streaming ML Pipeline:
┌──────┐    ┌───────┐    ┌─────────┐    ┌──────┐
│Kafka/│───▶│Kinesis│───▶│Analytics│───▶│Lambda│
│Source│    │Streams│    │(Flink)  │    │/SM   │
└──────┘    └───────┘    └─────────┘    └──────┘

Real-time Inference:
┌──────┐    ┌──────┐    ┌──────────┐    ┌──────┐
│Client│───▶│ API  │───▶│SageMaker │───▶│Result│
│      │    │  GW  │    │Real-time │    │      │
└──────┘    └──────┘    └──────────┘    └──────┘

SageMaker Pipelines Key Components

Hyperparameter Tuning Quick Reference

HPO Strategy

SageMaker Automatic Model Tuning

• Objective metric: specify training job metric to maximize/minimize
• Parameter ranges: continuous, integer, categorical
• Max jobs: total trials budget
• Max parallel jobs: concurrent trials (reduces wall time, less efficient)
• Warm starting: continue previous tuning job, transfer learning for HPO

Common Hyperparameter Effects

Model Monitoring Quick Reference

Key: All Model Monitor types need a baseline job first, then schedule monitoring job.

Mnemonics & Memory Aids

CART vs ID3: CART uses Gini, ID3 uses Entropy (C = Continuous splits, I = Information)

Precision vs Recall with “Spam”:

• Spam filter: Precision matters — FP means missing real email
• Cancer detection: Recall matters — FN means missed cancer

L1 vs L2 = “Lasso vs Ridge”:

• L1 Lasso = “L-one = L-ose features” (zeros out weights)
• L2 Ridge = “Ridge = gentle slope, no zeros”

Bagging vs Boosting:

• Bagging = Bootstrap samples + Broad parallel trees
• Boosting = Build on mistakes sequentially

SageMaker endpoint types — “RSBA”:

• Real-time (low latency, online)
• Serverless (intermittent, no idle cost)
• Batch transform (offline, no endpoint)
• Asynchronous (large payload, long running)

DeepAR vs classical forecasting:

• DeepAR = Deep learning for All related series at once Recurrently
• Use when you have many related time series (products, stores)

RCF for anomaly: Random Cut Forest = Real-time streaming anomalies Cut trees Find outliers

BlazingText modes:

• Supervised = text classification
• cbow / skipgram = word embeddings (like Word2Vec)

PCA vs t-SNE rule: PCA in production, t-SNE only for visualization (t-SNE is non-parametric, cannot transform new points)

Kinesis shard capacity:

• Ingestion: 1 MB/s or 1000 records/s per shard
• Consumption: 2 MB/s per shard

SageMaker Training job data: Always read from os.environ['SM_CHANNEL_TRAINING'] in script, save model to os.environ['SM_MODEL_DIR']

Spot training key requirement: MUST enable checkpointing — job can be interrupted and resumed

Ground Truth labeling: Use consolidation → reduce cost; use active learning → label only uncertain examples

Clarify = Bias + Explainability, Monitor = Drift detection over time

Cross-Validation Patterns

Time series: ALWAYS split by time, never random. Future data must never appear in training.

SageMaker Ground Truth

Labeling Workforce Options:
┌──────────────────────────────────────────┐
│  Amazon Mechanical Turk  │  Crowd         │
│  (public, cheap, fast)   │  (public)      │
├──────────────────────────────────────────┤
│  Vendor Managed          │  Private       │
│  (professional labels)   │  (your team)   │
└──────────────────────────────────────────┘

Active Learning Loop:
  Human labels sample → Train model → Auto-label easy examples
  → Send uncertain examples back to humans → Repeat

Ensemble Methods Quick Card

Transfer Learning Decision

Do you have labeled data?
│
├─ Lots of data (similar domain)   → Fine-tune all layers
├─ Lots of data (different domain) → Train from scratch
├─ Little data (similar domain)    → Freeze base, train head only
└─ Little data (different domain)  → Risky; use pretrained head if possible

AWS Data Processing Quick Sizing

Quick Recall: Domain Weights