PMLE Scaling Prototypes into ML Models Practice Test 6 — 15 Questions

Question 1

A data engineering team needs to compute rolling window features (7-day average, 30-day sum) from a high-volume stream of e-commerce events stored in BigQuery. They must output the features to Vertex AI Feature Store for online serving. Which approach is MOST cost-effective and scalable?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Use Dataflow with Apache Beam, reading from BigQuery, computing windowed aggregations, and writing to Vertex AI Feature Store. Dataflow (Apache Beam) is ideal for processing large-scale batch and streaming data. It can read from BigQuery, perform windowing computations, and write to Feature Store's online store. Cloud Functions have timeouts, Cloud Composer is not optimal for streaming, and BigQuery scheduled queries are not designed for streaming-feature computation.

Answer

Use Cloud Composer (Airflow) with a daily DAG to run SQL queries on BigQuery and export results

Answer

Schedule a query in BigQuery using scheduled queries and export results to Feature Store

Answer

Use Cloud Functions triggered by Pub/Sub to compute features on the fly

Question 2

A machine learning engineer wants to use Vertex AI Vizier to tune three hyperparameters: learning rate (log scale), number of layers (integer), and optimizer (categorical). They have 50 parallel trials available. Which parameter specification types should they define?

Accepted Answer

learning_rate: DOUBLE (unit_log_scale), layers: INTEGER (unit_linear_scale), optimizer: CATEGORICAL. Vertex AI Vizier requires parameter specifications that match the nature of each hyperparameter. Learning rate is best explored on a logarithmic scale, so it should be a DOUBLE parameter with unit_log_scale. Number of layers is a discrete integer count, so it should be an INTEGER parameter with unit_linear_scale. Optimizer is a categorical choice among named algorithms, so it should be CATEGORICAL. This combination correctly reflects the mathematical and structural properties of each hyperparameter.

Answer

learning_rate: CATEGORICAL, layers: INTEGER, optimizer: CATEGORICAL

Answer

learning_rate: DOUBLE (unit_log_scale), layers: DOUBLE (unit_linear_scale), optimizer: DISCRETE

Answer

learning_rate: DOUBLE (unit_linear_scale), layers: INTEGER (unit_linear_scale), optimizer: CATEGORICAL

Question 3

A team is fine-tuning a large language model (LLaMA 2) using Vertex AI with a custom container on a multi-node GPU cluster. They need to implement model parallelism to fit the model across multiple GPUs because it does not fit into a single GPU memory. Which distributed training strategy should they use?

Accepted Answer

Implement pipeline parallelism by manually splitting the model layers across GPUs and using a framework like PyTorch's RPC or Megatron-LM. When a model does not fit into a single GPU's memory, model parallelism is required. Pipeline parallelism splits the model layers across multiple GPUs, and frameworks like PyTorch's RPC or Megatron-LM provide the necessary primitives to implement it. This is the correct strategy for fitting a large model like LLaMA 2 across multiple GPUs.

Answer

Use Vertex AI Hyperparameter Tuning to find optimal model partitioning

Answer

Use tf.distribute.MirroredStrategy across all GPUs

Answer

Use Vertex AI distributed training with TF_CONFIG to set up multi-worker mirrored strategy and rely on XLA to partition the model

Question 4

An engineer is using TensorFlow Transform (tf.Transform) to preprocess training data. They want to ensure that the same preprocessing logic is applied during inference without code duplication. Which approach should they take?

Accepted Answer

Use tf.Transform to generate a transform_fn and save it as a SavedModel; then use tf.saved_model.load to apply it in the serving pipeline. TensorFlow Transform outputs a SavedModel that contains the preprocessing graph. This can be exported as a transform_fn and embedded in the serving model, ensuring consistency between training and serving.

Answer

Use tf.Transform at prediction time by running a separate Beam pipeline

Answer

Use Dataflow to preprocess data for both training and serving

Answer

Write separate preprocessing code for training and serving in Python

Question 5

A machine learning team is deploying a PyTorch model on Vertex AI Prediction for real-time inference. The model was trained with preprocessing that includes tokenization and normalization. They want to embed the preprocessing logic in the model to reduce prediction latency and avoid additional service calls. Which approach should they take?

Accepted Answer

Use TorchScript to trace the preprocessing steps and export the entire pipeline as a single scripted model. TorchScript allows you to trace or script a PyTorch model, including preprocessing operations like tokenization and normalization, into a single serialized artifact. By embedding preprocessing in the TorchScript model, the entire pipeline runs in one forward pass on the Vertex AI endpoint, eliminating extra service calls and reducing latency. This is the standard approach for consolidating preprocessing with a PyTorch model for real-time inference.

Answer

Deploy the preprocessing logic as a Cloud Function and invoke it before calling the prediction endpoint

Answer

Wrap the preprocessing logic in a Flask application and deploy it as a separate microservice in front of the prediction endpoint

Answer

Use TensorFlow Transform to convert preprocessing into a SavedModel and call it from the PyTorch model

Question 6

A team is training a large TensorFlow model that requires more memory than a single GPU provides. They have access to multiple GPUs on a single machine. Which distributed training strategy should they use to split the model layers across GPUs?

Accepted Answer

Manual device placement using tf.device to assign layers to specific GPUs. When a single model's layers exceed one GPU's memory, the model itself must be partitioned across devices — this is model parallelism. Manual device placement with tf.device('/GPU:0'), tf.device('/GPU:1'), etc. is the TensorFlow-native way to assign specific layers or operations to specific GPUs, splitting the model across them.

Answer

tf.distribute.experimental.MultiWorkerMirroredStrategy

Answer

tf.distribute.experimental.ParameterServerStrategy

Answer

tf.distribute.MirroredStrategy

Question 7

A company wants to train a custom machine learning model on Vertex AI using a pre-built container for scikit-learn. They want to use spot VMs to reduce costs. However, the training job fails intermittently due to preemption. Which TWO actions should they take to ensure the training job completes successfully?

Accepted Answer

Set the max_retry_count in the worker pool spec to a value greater than 0. To handle spot VM preemptions, the training job must be restartable. Using checkpoints allows the job to resume from the last saved state. Vertex AI automatically retries on preemption if the job is restartable (managed by the service). Setting max_retry_count in the worker pool spec allows Vertex AI to automatically restart the job after preemption. Also, reducing machine type or increasing parallel trials are not direct solutions.

Answer

Use a larger machine type to reduce training time

Answer

Increase the number of parallel trials in hyperparameter tuning

Answer

Set the worker_pool_specs to use spot VMs by setting spot=True

Question 8

A data scientist is training a very large neural network using Vertex AI with multiple GPUs across multiple nodes. The model does not fit on a single GPU, so they need to use both data parallelism and model parallelism (pipeline parallelism). Which THREE components or configurations are required to set up distributed training with Vertex AI?

Accepted Answer

Implementing pipeline parallelism manually in the training script using torch.distributed.pipeline.sync.Pipe. Pipeline parallelism requires explicit implementation in the training script, such as using `torch.distributed.pipeline.sync.Pipe` in PyTorch, to split the model layers across multiple GPUs. This is necessary when the model does not fit on a single GPU, and Vertex AI does not automatically handle model parallelism—it must be coded by the user.

Answer

Using Vertex AI Vizier to optimize the model parallelism strategy

Answer

Enabling Vertex AI AutoML to automatically distribute the model

Question 9

A data scientist has a TensorFlow 2.x model trained on a single GPU. They want to scale training to multiple GPUs on a single Vertex AI machine without code changes. Which strategy should they use?

Accepted Answer

MirroredStrategy. MirroredStrategy is TensorFlow's default single-machine, multi-GPU strategy. It replicates the model on each GPU and synchronizes gradients via all-reduce, and it can be enabled with minimal code changes (typically just wrapping model creation in strategy.scope()), making it the right choice for scaling on one Vertex AI machine.

Answer

MultiWorkerMirroredStrategy

Answer

TPUStrategy

Answer

CentralStorageStrategy

Question 10

You are fine-tuning a BERT model from Hugging Face Transformers on Vertex AI. You want to minimise cost for a short experiment. Which compute configuration should you use?

Accepted Answer

A custom training job with a single NVIDIA T4 GPU using spot VMs. A single NVIDIA T4 GPU with spot VMs is the most cost-effective choice for a short BERT fine-tuning experiment on Vertex AI. T4 GPUs are inexpensive and well-suited for moderate training workloads, and spot VMs offer up to 60-70% discount over regular VMs. Since the experiment is short, the risk of preemption is acceptable, and the cost savings are significant. This configuration balances performance and cost effectively.

Answer

A custom training job with a TPU v3-8 pod

Answer

A custom training job with 8 NVIDIA V100 GPUs using regular VMs

Answer

A standard n1-highmem-8 machine with no accelerator

Question 11

An ML engineer is using Vertex AI Vizier to tune hyperparameters for a PyTorch model. They want to maximise the chance of finding the global optimum within a fixed trial budget of 50 trials. Which algorithm should they select?

Accepted Answer

Bayesian optimisation. Bayesian optimisation (option B) is the correct choice because it builds a probabilistic surrogate model of the objective function and uses an acquisition function to balance exploration and exploitation, making it highly sample-efficient. With only 50 trials, Bayesian optimisation maximises the probability of finding the global optimum by focusing trials on the most promising hyperparameter regions, unlike random or grid search which waste trials on unpromising areas.

Answer

Random search

Answer

Grid search

Answer

Evolutionary algorithm

Question 12

You are using TensorFlow Transform (tf.Transform) to preprocess data for a model that will be deployed on Vertex AI. What is the primary benefit of using tf.Transform over Dataflow alone?

Accepted Answer

Training/serving skew prevention through a consistent transformation graph. tf.Transform computes statistics (e.g., min, max) on the full dataset, then generates a TensorFlow graph that applies the same transformation consistently at training and serving time. Dataflow alone does not ensure this consistency.

Answer

Support for GPUs during preprocessing

Answer

Built-in feature store integration

Answer

Faster data processing

Question 13

Your team is training a very large transformer model that does not fit on a single GPU. They are using Vertex AI custom training with PyTorch. Which distributed training approach should they use?

Accepted Answer

Model parallelism using pipeline parallelism. When a transformer model is too large to fit on a single GPU, model parallelism (specifically pipeline parallelism) is required because it splits the model's layers across multiple devices, with each device holding a subset of the model's parameters. Data parallelism (DDP) replicates the entire model on each GPU, which fails if the model exceeds a single GPU's memory. Pipeline parallelism allows training very large models by partitioning the model into stages and passing activations and gradients sequentially between devices.

Answer

Data parallelism using PyTorch DistributedDataParallel (DDP)

Answer

Horovod with allreduce

Answer

Vertex AI distributed training with TF_CONFIG

Question 14

An ML team is building a feature pipeline with Dataflow that reads from BigQuery, computes features, and writes to Vertex AI Feature Store. They need to ensure that features are available for both training and serving with low latency. Which Feature Store option should they use?

Accepted Answer

Create a featurestore with online serving enabled. To ensure features are available for both training and serving with low latency, the featurestore must have online serving enabled. Vertex AI Feature Store provides both online serving (low-latency reads for real-time predictions) and offline serving (batch reads for training). Enabling online serving allows the same feature values to be served at low latency during prediction, ensuring consistency between training and serving.

Answer

Create a featurestore with only offline serving

Answer

Store features directly in BigQuery

Answer

Use Cloud SQL as a feature store

Question 15

You need to run a custom training job on Vertex AI using a pre-built container for scikit-learn. Which container image should you specify?

Accepted Answer

us-docker.pkg.dev/vertex-ai/training/scikit-learn-cpu.0.23-0. For a scikit-learn custom training job on Vertex AI, you must specify a pre-built container image that includes scikit-learn. The correct image is us-docker.pkg.dev/vertex-ai/training/scikit-learn-cpu.0.23-0, which is the official Vertex AI pre-built training container for scikit-learn version 0.23 on CPU. Other images correspond to different frameworks (PyTorch, XGBoost, TensorFlow).

Answer

us-docker.pkg.dev/vertex-ai/training/pytorch-gpu.1-9

Answer

us-docker.pkg.dev/vertex-ai/training/xgboost-cpu.1-3

Answer

us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-6