PMLE domain - 21% of the exam

Scaling Prototypes Into ML Models

Scaling Prototypes Into ML Models is 21% of the PMLE exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

56
Practice questions
3
Objectives
36
Medium
20
Hard

Where people go wrong

  • Confusing data parallelism with model parallelism

    The wrong answers pick a parallelism strategy for the wrong constraint. Data parallelism, added replicas and a larger batch are offered when the model does not fit on one accelerator, and model parallelism is offered when the model already fits and only the dataset is slow. Data parallelism copies the whole model to every device and splits the batches, so it cuts training time but not per-device memory. Model parallelism partitions layers or parameters across devices so an oversized model can train at all.

    See it in a sample question
  • Assuming an accelerator speeds up any training job

    The wrong answers offer a GPU, a TPU slice or a GPU cluster for gradient-boosted trees and tabular feature engineering, and a TPU for work that is starved by its input pipeline or that needs dynamic shapes and custom kernels. Accelerators pay off on large dense matrix multiplications. A workload without them leaves the accelerator idle but still billed, so a CPU is the cheaper fit, and an input-bound job needs a better input pipeline rather than faster compute.

    See it in a sample question
  • Matching the serving mode to the wrong demand

    The wrong answers pair batch prediction with a need for an answer within milliseconds or seconds, and pair an always-warm endpoint, many synchronous calls or a polled cycle with bulk scoring or long idle stretches. An online endpoint with autoscaling answers single requests quickly and scales down when idle. A batch prediction job scores a whole bounded table in one run and then stops, so bulk scoring pays for no standing replicas.

    See it in a sample question
  • Treating a plausible explanation as a feature attribution

    The wrong answers offer something that reads like an explanation: a generated narrative from an LLM, a global feature ranking, raw DNN weights or a confidence score. None of these shows the contribution of every input feature to each individual decision, which is what the regulator in these questions requires. An AutoML tabular classifier with built-in feature attributions, or an inherently interpretable model such as logistic regression, does.

    See it in a sample question
  • Sending a single univariate forecast to a heavyweight model

    The wrong answers offer a DNN, a transformer on a cluster or an LLM for one series with limited history, a small budget, no GPU and a SQL-only team. ARIMA is built for one univariate series with trend and seasonality, runs without a GPU and gives interpretable components. In BigQuery ML the team trains and forecasts in SQL, so the results stay in BigQuery for the dashboards.

    See it in a sample question

Objectives in this domain

Sample questions from this domain

Free sampleScaling Prototypes Into ML Modelsmedium

A research team is training a model whose parameter count is so large that the weights and optimiser state cannot fit into the memory of any single accelerator they have available, even at a batch size of one. They have a multi-device TPU slice and need a strategy that lets the model train at all. Which approach is appropriate?

  • AData parallelism, replicating the full model on every device and sharding the input batch so each device trains on a different subset of examples.
  • BModel parallelism, partitioning the model's layers and parameters across the devices so each holds only part of the network and they cooperate on each step. Correct
  • CGradient accumulation on one device, summing gradients over several micro-batches before applying a single optimiser update to the weights.
  • DMixed-precision training on one device, storing weights in lower precision so the existing single accelerator can hold the whole model.
Apply model parallelism when a model is too large to fit in any single accelerator's memory. When parameters and optimiser state exceed a single device's memory even at batch size one, model parallelism is required: it distributes distinct layers or parameter shards across multiple devices so the whole model never resides on one accelerator, whereas data parallelism, accumulation, and lower precision all still assume the model fits on one device.

Why A is wrong: It is tempting because data parallelism is the common default for scaling, but it requires a full copy of the model on every device, which is impossible here because the model does not fit on a single accelerator.

Why B is correct: Model parallelism splits the parameters and layers across devices so no single device must hold the whole model, which is the only way to train when the network exceeds one accelerator's memory even at batch size one.

Why C is wrong: It is tempting because accumulation reduces memory pressure from activations, but it still keeps the entire model and optimiser state on one device, so it cannot help when the parameters themselves do not fit.

Why D is wrong: It is tempting because lower precision does shrink memory use, but the reduction is modest and will not make a model that overflows the device at batch size one suddenly fit, so a single device remains insufficient.

Free sampleScaling Prototypes Into ML Modelsmedium

A team's training job spends almost all of its time on heavy tabular feature engineering, string parsing, and joins over a moderate dataset, after which it fits a small gradient-boosted tree whose arithmetic is trivial. They benchmarked the same job on a GPU instance and saw no speed improvement over a cheaper instance, because the workload contains almost no large dense matrix multiplications. Which hardware choice best fits this training workload?

  • AA CPU instance, because the workload is dominated by data preparation and branchy tree-building logic that gain nothing from a matrix-multiply accelerator. Correct
  • BA single high-memory GPU, because its many parallel cores will accelerate the feature joins and the tree-building arithmetic together.
  • CA multi-chip TPU slice, because TPUs deliver the highest throughput for this kind of batch training job.
  • DA GPU cluster with data parallelism, because sharding the input across several GPUs will cut the wall-clock training time.
Choose a CPU when the workload lacks large dense matrix multiplications, since GPUs and TPUs only help matmul-bound training. GPUs and TPUs accelerate large dense matrix multiplications; gradient-boosted tree fitting and tabular feature engineering are dominated by branching, memory access, and joins, so an accelerator stays underused and a CPU is both cheaper and equally fast for this profile.

Why A is correct: This is correct: gradient-boosted trees and feature engineering are control-flow and memory heavy rather than dense-matmul heavy, so a CPU avoids paying for an idle accelerator.

Why B is wrong: This is tempting because GPUs accelerate many ML jobs, but feature joins and tree splits are not dense matrix operations, so the GPU sits underused while still being billed.

Why C is wrong: This is tempting given TPUs' raw throughput, but TPUs are specialised for large dense matrix multiplications and offer no benefit to tree-based or data-wrangling workloads.

Why D is wrong: This is plausible because data parallelism cuts time for compute-bound jobs, but here the bottleneck is non-matmul preprocessing, so extra GPUs add cost without removing the actual bottleneck.

Free sampleScaling Prototypes Into ML Modelsmedium

A payments company must score transactions for fraud in under 50 milliseconds at thousands of requests per second, around the clock. A trained model already exists. The platform team wants automatic scaling under bursty load while avoiding paying for idle capacity during quiet overnight periods. Which deployment strategy best meets the latency and scalability goals?

  • ASchedule a batch prediction job every few minutes that scores the queued transactions and writes verdicts to a table the checkout service polls.
  • BProvision a fixed fleet of always-on prediction nodes sized for peak traffic so capacity never has to scale during bursts.
  • CDeploy the model to an online prediction endpoint with autoscaling configured on request load and a minimum replica count sized for baseline traffic. Correct
  • DRun the model behind an ML pipeline that retrains and redeploys on each transaction so the freshest weights handle every request.
Select an autoscaling online prediction endpoint when real-time latency and bursty, cost-sensitive traffic must both be served. Online endpoints keep models warm for synchronous millisecond responses, and request-driven autoscaling expands replicas under spikes then contracts during lulls, balancing the latency requirement against the cost of idle capacity.

Why A is wrong: Batch prediction is cheaper for bulk scoring, but micro-batching every few minutes cannot deliver a 50 millisecond synchronous answer, so legitimate purchases would stall waiting on the polled table.

Why B is wrong: A peak-sized static fleet does meet latency, but it pays full price through the quiet overnight hours and still fails to absorb spikes beyond the fixed ceiling, wasting money the team wants to save.

Why C is correct: An online endpoint gives the low single-digit latency real-time scoring needs, while load-based autoscaling adds replicas during bursts and scales back overnight so the team is not paying for idle peak capacity.

Why D is wrong: Pipelines are right for orchestrating training and retraining, but retraining per request adds huge latency and cost and confuses the training workflow with the serving path the question is about.

Free sampleScaling Prototypes Into ML Modelsmedium

An insurance team must predict claim approval from structured policyholder data. A regulator requires that every individual decision be explained with the contribution of each input feature, and the data scientists have limited modelling experience but want strong accuracy without writing custom training code. Which approach best balances accuracy, low build effort, and the interpretability requirement?

  • APrompt a large language model with the policy fields and ask it to both approve or deny and narrate the reasons in plain language for each case.
  • BHand-build a deep neural network and rely on its raw learned weights to show how each feature drove every individual approval decision.
  • CFit a classic linear ARIMA forecaster to the policy fields so its coefficients serve as the required per-feature explanations of each decision.
  • DTrain an AutoML tabular classifier and enable built-in feature-attribution explanations to report each feature's contribution per prediction. Correct
Use AutoML tabular with built-in feature attributions when high accuracy, low build effort, and per-decision interpretability are all required. AutoML tabular automates model selection and tuning for low effort, and its example-based feature-attribution output quantifies how much each input moved an individual prediction, which is what regulated per-decision interpretability demands.

Why A is wrong: An LLM narrative reads like an explanation, but it is a generated rationalisation rather than a faithful per-feature attribution, so it cannot satisfy a regulator demanding measurable feature contributions on tabular data.

Why B is wrong: A DNN can be accurate, but raw weights are not directly readable as per-decision attributions and building one needs the custom coding the inexperienced team wants to avoid.

Why C is wrong: ARIMA coefficients are interpretable, which is the lure, but ARIMA is a time-series method and is simply the wrong model family for static structured classification of claims.

Why D is correct: AutoML tabular delivers strong accuracy with little coding for an inexperienced team, and its built-in feature attributions give the regulator the per-decision contribution of each input the rules require.

Free sampleScaling Prototypes Into ML Modelsmedium

A retail analyst has eighteen months of a single weekly sales figure and needs short-horizon forecasts with clear, decomposable trend and seasonality, on a modest budget and with no GPU access. Which model type best fits these constraints?

  • AA large language model prompted with the historical figures, because it can reason over sequences and produce a forecast narrative for stakeholders.
  • BAn ARIMA model, because it is purpose-built for univariate time series with limited history and yields interpretable trend and seasonal components cheaply. Correct
  • CA deep neural network with recurrent layers, because it captures complex non-linear patterns and scales to many future periods automatically.
  • DA gradient-boosted tree ensemble, because it handles tabular features robustly and trains quickly on commodity hardware for this dataset.
Match a univariate, small-sample, low-cost forecasting need to ARIMA over DNN or LLM approaches. ARIMA's autoregressive, integrated, and seasonal structure is designed for univariate series, estimates reliably from short histories, and yields interpretable components, whereas DNNs and LLMs demand more data, more compute, and offer less decomposability.

Why A is wrong: Tempting because LLMs handle sequences and generate readable output, but they are costly, non-deterministic for numeric forecasting, and do not give the decomposable trend and seasonality the analyst needs.

Why B is correct: Correct: ARIMA targets univariate series, performs well on small samples, runs without GPUs, and exposes decomposable autoregressive, integrated, and seasonal terms that meet every stated constraint.

Why C is wrong: Tempting because DNNs model non-linear patterns well, but they need far more data than eighteen weekly points, usually want GPUs, and obscure the trend and seasonality the analyst must explain.

Why D is wrong: Tempting because boosted trees are cheap and strong on tabular data, but they ignore temporal ordering by default and do not natively decompose trend and seasonality without heavy manual feature engineering.

Other domains in this exam

See also the PMLE cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by Google Cloud. Original, blueprint-aligned practice material only.