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

Question 1

A data scientist wants to train a PyTorch model on Vertex AI using a pre-built container for GPU training. She needs to use 4 NVIDIA A100 GPUs on a single machine. Which machine configuration should she select?

Accepted Answer

a2-highgpu-4g (4 A100 GPUs). Vertex AI offers pre-built containers for PyTorch that support GPU training. To use 4 A100 GPUs, the machine type should be 'a2-highgpu-4g', which provides 4 A100 GPUs. The 'n1-standard-16' only supports up to 4 GPUs but typically uses P100 or T4, and 'n1-highmem-16' can support up to 4 GPUs but the GPU type is not A100 by default. The 'a2-megagpu-16g' provides 16 GPUs.

Answer

n1-highmem-16 with 4 NVIDIA V100 GPUs

Answer

n1-standard-16 with 4 NVIDIA T4 GPUs

Answer

a2-megagpu-16g (16 A100 GPUs)

Question 2

An ML engineer is using Vertex AI Vizier to tune hyperparameters for a custom training job. The training job takes 2 hours per trial. To speed up the process, the engineer wants to run 10 trials in parallel. What is the correct way to configure parallel trial execution?

Accepted Answer

Set the 'parallelTrialCount' parameter in the study configuration to 10. In Vertex AI Vizier, parallel trial execution is configured by setting the 'parallelTrialCount' field in the study configuration. The maxParallelTrials is not a direct field; instead, the StudySpec contains a StudyJobConfig with parallelTrialCount. Setting parallelTrialCount to 10 allows up to 10 trials to run concurrently.

Answer

Use the '--parallel-trials' flag in the gcloud ai hp-tuning-jobs create command

Answer

Set the 'maxParallelTrials' attribute in the HyperparameterSpec

Answer

Create a CustomJob with 'numTrials' set to 10 and 'parallel' flag

Question 3

A team is building a feature pipeline for an ML model. They need to compute aggregate features over a sliding time window from streaming data. Which Google Cloud service is most appropriate for this task?

Accepted Answer

Cloud Dataflow with fixed windows. Cloud Dataflow with fixed windows is the most appropriate choice because it natively supports windowing and aggregation over streaming data using the Apache Beam programming model. Fixed windows allow you to define sliding time intervals (e.g., every 5 minutes) to compute aggregate features like sums or averages, which is exactly what the feature pipeline requires.

Answer

Cloud Pub/Sub for windowing logic

Answer

BigQuery scheduled queries

Answer

Cloud Functions with Pub/Sub triggers

Question 4

An ML team is fine-tuning a large language model using a custom container on Vertex AI. They want to reduce costs by using preemptible (spot) VMs for training. The training job is long-running and uses checkpointing. Which statement is correct regarding spot VM usage?

Accepted Answer

You must enable checkpointing in the training code and use spot VMs by setting the 'spot' field in the machine spec. Option C is correct because Vertex AI custom training jobs support spot VMs, but you must explicitly enable checkpointing in your training code and set the 'spot' field in the machine spec to true. This ensures that when a preemptible VM is terminated, the training can resume from the latest checkpoint, preventing loss of progress and reducing costs.

Answer

Spot VMs are not available for custom training jobs on Vertex AI

Answer

Training will automatically resume from the latest checkpoint without any configuration

Answer

Spot VMs cannot be used with GPU accelerators

Question 5

A machine learning engineer is training a TensorFlow model on Vertex AI using distributed training with the MultiWorkerMirroredStrategy. The training job uses 4 workers with 4 GPUs each. The engineer notices that the training is not scaling linearly. What is the most likely cause?

Accepted Answer

Communication overhead due to gradient synchronization. With MultiWorkerMirroredStrategy, each worker computes gradients independently on its local batch, then all-reduces gradients across workers via collective communication (e.g., NCCL or gRPC). As the number of workers increases, the communication overhead for gradient synchronization grows, often dominating the per-step time and preventing linear scaling. This is the most common bottleneck in distributed TensorFlow training, especially with many workers or small batch sizes per worker.

Answer

The model architecture is too simple to benefit from distribution

Answer

The workers are not using the same version of TensorFlow

Answer

The GPUs are not configured correctly

Question 6

An organization wants to deploy a pre-trained BERT model for sentiment analysis on Vertex AI. They want to fine-tune it on their domain-specific data. Which feature in Vertex AI allows them to find and fine-tune a suitable foundation model with minimal effort?

Accepted Answer

Vertex AI JumpStart. Vertex AI JumpStart provides one-click deployment and fine-tuning of foundation models, including BERT and other NLP models. Model Garden is for model discovery, but fine-tuning is typically done via JumpStart. AutoML is for training custom models, not fine-tuning existing ones. Custom training requires more manual effort.

Answer

Vertex AI Model Garden

Answer

Vertex AI AutoML

Answer

Vertex AI Custom Training

Question 7

A machine learning engineer is deploying a TensorFlow model on an edge device with limited memory and compute. The model needs to perform inference with low latency. The engineer has a trained float32 model. Which model compression technique should be applied first to reduce the model size and improve inference speed without significant accuracy loss?

Accepted Answer

Post-training quantization to INT8. Post-training quantization to INT8 is the correct first step because it directly reduces the model size by approximately 4x (from 32-bit floats to 8-bit integers) and speeds up inference on edge devices by leveraging integer-optimized hardware (e.g., ARM NEON or Qualcomm Hexagon). This technique requires no retraining and typically yields minimal accuracy loss for most TensorFlow models, making it the fastest path to deploy on resource-constrained devices.

Answer

Knowledge distillation

Answer

Quantization-aware training

Answer

Weight pruning

Question 8

A data scientist wants to use tf.Transform for preprocessing a large dataset stored in BigQuery before training a TensorFlow model. The preprocessing should be consistent during training and serving. What is the correct way to use tf.Transform in this scenario?

Accepted Answer

Use tf.Transform to define a preprocessing_fn and apply it to the dataset, then export the transform graph for serving. Option C is correct because tf.Transform is specifically designed to handle full-pass preprocessing (e.g., computing min/max, vocabularies) that requires seeing the entire dataset. By defining a `preprocessing_fn` and applying it via `tft.beam.analyze_and_transform`, the transform graph is exported as a SavedModel, which can be loaded during serving to ensure identical preprocessing logic. This guarantees consistency between training and inference, which is critical for production ML pipelines.

Answer

Write preprocessing logic in Python and reuse the same code in training and serving

Answer

Use BigQuery's built-in ML.TRANSFORM function for consistency

Answer

Use a Lambda layer in Keras for preprocessing

Question 9

A team is training a large image classification model using transfer learning from a pre-trained ResNet50. The model will be deployed on mobile devices. They want to fine-tune only the last few layers while keeping the earlier layers frozen. Which approach should they use?

Accepted Answer

Load ResNet50, freeze all layers, add new classification layers, and train only the new layers. Transfer learning typically involves loading a pre-trained model (e.g., ResNet50 from Keras Applications) without the top classification layer, freezing all layers, adding new trainable layers on top, and then training. The base model's layers are frozen (trainable=False). After initial training, one can optionally unfreeze some top layers.

Answer

Load ResNet50, set trainable=False for all layers, and replace the final dense layer only

Answer

Load ResNet50 from Keras Applications, set trainable=True for all layers, add new layers, and train the entire model

Answer

Use AutoML Vision to transfer learn without coding

Question 10

An engineer is training a model on Vertex AI using a custom container. The training job fails with an error indicating that the container exited with a non-zero status. The engineer wants to debug the issue. What is the best way to access the logs?

Accepted Answer

Check the logs in Cloud Logging (Logs Explorer). Option D is correct because Vertex AI automatically streams all container stdout and stderr to Cloud Logging (Logs Explorer). When a custom container exits with a non-zero status, the detailed error messages, stack traces, and application logs are captured there, making it the primary and most comprehensive debugging tool. Cloud Logging provides structured, searchable logs without requiring direct access to the container.

Answer

SSH into the training container using Vertex AI's SSH feature

Answer

View logs in Cloud Storage under the job's output directory

Answer

Use Cloud Debugger to inspect the container

Question 11

A research team is training a very large Transformer model that does not fit into the memory of a single GPU. They have access to multiple GPUs on a single machine and want to split the model layers across GPUs. Which distributed training strategy should they use?

Accepted Answer

Pipeline parallelism (model parallelism). When a model is too large for one GPU, model parallelism (pipeline parallelism) is required. This splits different layers (or layer groups) across devices. Data parallelism (mirrored strategy) replicates the model, which would still require the full model on each GPU. Pipeline parallelism is a form of model parallelism where layers are distributed across devices and micro-batches flow through the pipeline.

Answer

MultiWorkerMirroredStrategy

Answer

Parameter server strategy

Answer

MirroredStrategy (data parallelism)

Question 12

An ML team wants to use Vertex AI Hyperparameter Tuning to tune a custom training job. They have a budget of 50 trials and want to use an algorithm that balances exploration and exploitation. Which algorithm should they choose?

Accepted Answer

Bayesian optimization (Vizier default). Bayesian optimization (the default algorithm in Vertex AI Vizier) is the correct choice because it explicitly balances exploration and exploitation by building a probabilistic model of the objective function and using an acquisition function to select the next hyperparameter configuration. With a budget of 50 trials, this algorithm efficiently converges to optimal regions while still exploring uncertain areas, making it ideal for tuning custom training jobs where each trial is computationally expensive.

Answer

Random search

Answer

Grid search

Answer

Manual search

Question 13

A company is deploying a TensorFlow model on Vertex AI Prediction. The model is memory-intensive and requires GPU acceleration. The team wants to minimize latency and cost. Which TWO configurations should they select? (Select 2)

Accepted Answer

Use NVIDIA T4 GPUs. For GPU-accelerated prediction, the T4 GPU is cost-effective and provides good performance for inference. Autoscaling with a minimum of 1 instance ensures availability while allowing the service to scale down when not in use. A100 is more expensive; batch prediction is for asynchronous large-scale jobs; manual scaling may lead to over-provisioning.

Answer

Use NVIDIA A100 GPUs for faster inference

Answer

Set manual machine count to 10 for consistent performance

Answer

Use batch prediction to reduce cost

Question 14

An ML engineer is using Vertex AI for distributed training of a PyTorch model across multiple nodes. The training job must use TPUs for high throughput. The engineer sets up the job configuration. Which THREE components are required for the training to work correctly? (Select 3)

Accepted Answer

A startup script to configure the TPU pod (e.g., `xla_lib.sh`). A is correct because TPU pods require a startup script (e.g., `xla_lib.sh`) to initialize the XLA runtime, configure the TPU mesh, and set environment variables like `XRT_TPU_CONFIG`. Without this script, the TPU devices will not be discoverable by the PyTorch/XLA process, causing the training to fail with device-not-found errors.

Answer

A MultiWorkerMirroredStrategy configuration

Answer

A TF_CONFIG environment variable set for each worker

Question 15

A machine learning team is building a feature engineering pipeline using Dataflow. They need to compute features from streaming data and store them in Vertex AI Feature Store for online serving. The features must be updated within 5 seconds of the event. Which TWO services should they combine? (Select 2)

Accepted Answer

Cloud Dataflow for stream processing and feature computation. Cloud Dataflow is correct because it provides unified stream and batch processing with exactly-once semantics, enabling low-latency feature computation from streaming data. It integrates natively with Vertex AI Feature Store for online serving, ensuring features are updated within the required 5-second SLA.

Answer

Cloud Storage for feature store

Answer

Cloud Functions for feature transformation

Answer

BigQuery for feature storage