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

Question 1

You need to reduce the cost of training a large model on Vertex AI while maintaining fault tolerance. Which THREE actions should you take? (Choose 3)

Accepted Answer

Use spot VMs. Spot VMs are cheaper but can be preempted; using checkpointing and saving to a durable storage (like GCS) allows recovery. Also, using a single node with multiple GPUs may be cheaper than multiple nodes.

Answer

Use MultiWorkerMirroredStrategy

Answer

Use TPUs instead of GPUs

Question 2

You are fine-tuning a Gemma model using Vertex AI JumpStart. You want to combine the fine-tuned model with a custom output layer for a unique task. Which TWO components are required to deploy the combined model? (Choose 2)

Accepted Answer

Vertex AI Model Registry. To customize the output layer, you need a custom container that loads both the fine-tuned base model and your custom head. The model must be registered in Vertex AI Model Registry for deployment.

Answer

Vertex AI Feature Store

Answer

Cloud Run

Answer

Pre-built container for Gemma

Question 3

A data scientist needs to train a large PyTorch model on a custom dataset using Vertex AI. The training script expects data from Cloud Storage and uses GPU acceleration. Which option correctly configures a custom training job with a pre-built container for PyTorch and attaches a single NVIDIA V100 GPU?

Accepted Answer

Use the pre-built container 'us-docker.pkg.dev/vertex-ai/training/pytorch-gpu.1-12:latest' and in worker_pool_specs set machine_type='n1-standard-4', accelerator_type='NVIDIA_TESLA_V100', accelerator_count=1. In Vertex AI, worker_pool_specs define machine types and accelerators. Using a pre-built container for PyTorch 1.12 with image_uri 'us-docker.pkg.dev/vertex-ai/training/pytorch-gpu.1-12:latest' and specifying worker_count=1, machine_type='n1-standard-4' (or similar), and accelerator_type='NVIDIA_TESLA_V100' with count=1 sets up the job correctly.

Answer

Use a custom container built from PyTorch base image and specify accelerator_count=1 in the machine spec

Answer

Use the AI Platform Training service with gcloud ai-platform jobs submit training and --scale-tier BASIC_GPU

Answer

Create a training pipeline with AutoML and select GPU runtime

Question 4

A machine learning engineer is preparing to train a Transformer-based model using TensorFlow on a single TPU v3-8 pod slice. The training script uses tf.distribute.TPUStrategy. Which environment variable must be set in Vertex AI to enable TPU training with the appropriate topology?

Accepted Answer

TPU_CONFIG. Vertex AI automatically sets the TPU_CONFIG environment variable to communicate the TPU worker IP address and port to the training container. TF_CONFIG is used for distributed training with CPUs/GPUs, but TPU_CONFIG is the correct one for TPU training.

Answer

TPU_NAME

Answer

XRT_TPU_CONFIG

Answer

TF_CONFIG

Question 5

A team wants to perform hyperparameter tuning on a Vertex AI custom training job with 100 trials. They require an algorithm that efficiently explores the search space by learning from previous trials. Which algorithm should they select in the study configuration?

Accepted Answer

ALGORITHM_UNSPECIFIED (defaults to Bayesian optimization). Vertex AI Vizier provides Bayesian optimization as a default algorithm that builds a probabilistic model of the objective function and selects hyperparameters based on expected improvement. This is more efficient than grid or random search for most scenarios. The ALGORITHM_UNSPECIFIED defaults to Bayesian optimization.

Answer

RANDOM_SEARCH

Answer

HYPERBAND

Answer

GRID_SEARCH

Question 6

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?

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 7

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. In Vertex AI Vizier, continuous parameters use DOUBLE type (can be scaled log), integer parameters use INTEGER, and categorical parameters use CATEGORICAL. The scale type for learning rate should be UNIT_LOG_SCALE for log scale.

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 8

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. Model parallelism, specifically pipeline parallelism, splits the model layers across devices. For large models that don't fit on one GPU, this is necessary. Data parallelism (even with ZeRO) still requires the full model on each device. Vertex AI does not natively support model parallelism; users must configure it manually using frameworks like Megatron-LM or DeepSpeed.

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 9

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 10

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 exporting the entire model (including preprocessing) into a serialized format that can be run without Python dependencies. This reduces latency as all operations are within the exported graph. Wrapping in a Flask app or using Cloud Functions would introduce overhead. Training with tf.Transform is not applicable for PyTorch.

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 11

A data scientist wants to quickly experiment with a pre-trained Vision Transformer model from Hugging Face and fine-tune it on a custom dataset using Vertex AI. They want to use a managed environment with minimal setup. Which Vertex AI service should they use?

Accepted Answer

Vertex AI JumpStart. Vertex AI JumpStart is the correct choice because it provides a managed environment with pre-built, optimized containers for popular models like Vision Transformers, enabling one-click deployment and fine-tuning with minimal setup. It abstracts away infrastructure management, allowing the data scientist to quickly experiment without configuring custom training scripts or environments.

Answer

Vertex AI Prediction

Answer

Vertex AI Workbench

Answer

AI Platform Training

Question 12

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. Model parallelism splits the model itself across devices, as opposed to data parallelism which replicates the model. For TensorFlow, this is typically achieved using device placement or tf.distribute.experimental.ParameterServerStrategy with manual partitioning, but for splitting layers, tf.distribute.experimental.DeviceAssignment or manual tf.device is used.

Answer

tf.distribute.experimental.MultiWorkerMirroredStrategy

Answer

tf.distribute.experimental.ParameterServerStrategy

Answer

tf.distribute.MirroredStrategy

Question 13

A company is deploying a deep learning model on edge devices with limited storage and computational resources. They need to reduce the model size by 80% while maintaining acceptable accuracy. Which two techniques should they combine?

Accepted Answer

Quantization and pruning. Quantization reduces model size by converting weights from FP32 to INT8, achieving up to 75% size reduction. Pruning removes redundant weights (e.g., 50% pruning) to further shrink the model. Together, these two techniques can reduce model size by over 80% (e.g., 50% pruning + INT8 quantization yields ~87.5% reduction) while preserving acceptable accuracy on edge devices. Knowledge distillation also reduces size but typically requires a pre-trained teacher and may not achieve the extreme compression needed when combined with quantization alone.

Answer

Pruning and distillation

Answer

Quantization and distillation

Question 14

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 15

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