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

Question 1

A data scientist is fine-tuning a large language model from Hugging Face using Vertex AI Training with a GPU. The model has 7 billion parameters and does not fit on a single GPU. They need to split the model across multiple GPUs and train with data parallelism. Which strategy should they use?

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

Accepted Answer

Use pipeline parallelism via a custom container with DeepSpeed and data parallelism across workers using PyTorch DDP, configured with Vertex AI distributed training.. It combines pipeline parallelism (via DeepSpeed) to split the 7B-parameter model across multiple GPUs, with data parallelism (via PyTorch DDP) to replicate the model across workers for training on larger batches. Vertex AI distributed training coordinates the multi-worker setup, making this the only viable strategy for a model that exceeds single-GPU memory while requiring data parallelism.

Answer

Use Vertex AI's AutoML to automatically distribute the model.

Answer

Use Vertex AI's hyperparameter tuning with multiple trials.

Answer

Configure a multi-worker mirrored strategy with TensorFlow, setting TF_CONFIG to use all GPUs on each worker.

Question 2

A developer wants to quickly deploy a pre-trained foundation model for text generation without writing any code. Which Vertex AI feature should they use?

Accepted Answer

Vertex AI JumpStart. Vertex AI JumpStart is a feature within Vertex AI Model Garden that provides a no-code, one-click deployment experience for pre-trained foundation models. It allows developers to select a model, configure deployment settings through a simple UI, and deploy to an endpoint without writing any code. This directly matches the requirement of quickly deploying a pre-trained foundation model for text generation without coding.

Answer

Vertex AI Model Garden

Answer

Vertex AI Endpoints

Answer

Vertex AI AutoML

Question 3

A team is using TensorFlow Transform (tf.Transform) to create preprocessing functions that will be used both in training and serving. They want to ensure consistency. Which artifact should they save after analyzing the training data?

Accepted Answer

A transform_fn SavedModel.. The correct artifact to save after analyzing training data with tf.Transform is the `transform_fn` SavedModel. This SavedModel encapsulates the exact preprocessing logic (e.g., scaling, normalization, vocabulary mapping) computed from the training dataset, ensuring that the same transformations are applied consistently during both training and serving. Without this artifact, the serving pipeline would need to recompute or duplicate the transformation logic, risking skew between training and inference.

Answer

A trained model checkpoint.

Answer

A analyzed_dataset directory with statistics.

Answer

A flattened schema file (schema.pbtxt).

Question 4

An organization wants to use Vertex AI JumpStart to fine-tune a foundation model for a custom classification task. They have a labeled dataset stored in BigQuery. Which steps should they take?

Accepted Answer

Use the Vertex AI console to select a model from JumpStart, specify the BigQuery table as the source, and launch fine-tuning.. Vertex AI JumpStart provides a console and API workflow where you select a foundation model, choose a tuning method (e.g., supervised fine-tuning), and point to a BigQuery table or Cloud Storage URI as the training data source. The console handles the pipeline, so no custom training script is needed.

Answer

Export the data from BigQuery to CSV files in Cloud Storage, then upload to JumpStart.

Answer

Write a custom training script using PyTorch and submit to Vertex AI Training.

Answer

Use Vertex AI Model Garden to deploy the model directly without fine-tuning.

Question 5

A machine learning team is training a large transformer model on Vertex AI. They need to reduce training time by utilizing multiple GPUs across nodes, but the model is too large to fit into a single GPU memory. Which distributed training strategy should they use?

Accepted Answer

Model parallelism using tf.distribute.experimental.PipelineMirroredStrategy. PipelineMirroredStrategy combines model parallelism (splitting the transformer layers across multiple GPUs) with pipeline parallelism to handle models that exceed single GPU memory. This strategy partitions the model into stages, each placed on a different GPU, and uses micro-batching to keep all GPUs busy, which is essential for large transformer models that cannot fit into a single GPU's memory.

Answer

Data parallelism using tf.distribute.MirroredStrategy

Answer

Multi-worker mirrored strategy with a single worker per node

Answer

Hyperparameter tuning with Vertex AI Vizier

Question 6

You are setting up a hyperparameter tuning job on Vertex AI for a large neural network. The objective is to minimize validation loss. You want to explore the hyperparameter space efficiently with a limited budget of 100 trials. Which THREE settings should you configure in the study?

Accepted Answer

Enable early stopping. Enabling early stopping in Vertex AI hyperparameter tuning terminates poorly performing trials early, saving the trial budget for more promising hyperparameter configurations. This is critical when the objective is to minimize validation loss with a limited budget of 100 trials, as it prevents wasting resources on suboptimal runs and allows the search to focus on the most promising regions of the hyperparameter space.

Answer

Algorithm: GRID_SEARCH

Answer

Disable early stopping

Question 7

A team is training a custom TensorFlow model on Vertex AI using a pre-built container. They need to use a TPU pod slice (v3-32). What THREE actions are required to set up the training job correctly?

Accepted Answer

Configure TF_CONFIG for distributed training. Option A is correct because a TPU pod slice (v3-32) is a distributed training environment, and TensorFlow requires the TF_CONFIG environment variable to define the cluster specification (worker, master, and TPU worker roles) so each worker process knows its task type and index. Option C is correct because Vertex AI custom training jobs specify TPU accelerators via acceleratorType: TPU_V3 and a topology string; for a v3-32 pod slice the topology is '2x2x4' (which equals 32 TPU v3 cores), and this must be set in the worker pool's machine spec. Option B is wrong because a TPU pod slice inherently requires multiple workers (v3-32 has 32 cores across 4 hosts), so restricting the worker pool to one worker would not provision the pod slice. Option D is wrong because the scenario explicitly uses a pre-built container, so a custom container is unnecessary and contradicts the requirement. Option E is wrong because NVIDIA A100 GPUs are GPU accelerators, not TPUs, and would not satisfy the TPU v3-32 pod slice requirement.

Answer

Set the training worker pool to use only one worker

Answer

Use a custom container with TensorFlow 2.12 and TPU support

Answer

Set the machine type to a high-memory VM with NVIDIA A100 GPUs

Question 8

A company is deploying a computer vision model on edge devices using TensorFlow Lite. They want to reduce model size without significant accuracy loss. Which TWO model compression techniques are most suitable?

Accepted Answer

Weight pruning. Weight pruning (B) is suitable because it removes redundant connections (weights) from the neural network, reducing the model size and computational cost while often preserving accuracy if done gradually. Post-training float16 quantization (D) converts model weights from float32 to float16, halving the storage size with minimal accuracy loss, and is directly supported by TensorFlow Lite for edge deployment.

Answer

Quantization-aware training (QAT)

Answer

Knowledge distillation

Answer

Increasing model depth

Question 9

You are using tf.Transform to preprocess data for a TensorFlow model. You want to ensure that the same transformations applied during training are also applied during serving. Which THREE components are necessary to achieve this?

Accepted Answer

Use the tf.Transform analyze_and_transform function on the training data. `tf.Transform.analyze_and_transform` computes the full-pass statistics (e.g., mean, variance, vocabulary) needed for consistent preprocessing and applies the transformation to the training data. This function produces a `tf.Transform` graph that captures the exact operations, ensuring the same transformation logic is available for both training and serving.

Answer

Store raw data in BigQuery for serving

Answer

Duplicate the preprocessing code in the serving application

Question 10

You are preparing to submit a Vertex AI custom training job using the Python SDK for a scikit-learn model. The job must run on a single n1-standard-4 VM with no GPU, and you need to minimize cost while ensuring the training code can install necessary Python packages at runtime. Which approach should you use?

Accepted Answer

Use a pre-built training container and include a requirements.txt file in your Python package; the container automatically installs dependencies before running the training script.. For custom training with a pre-built container, Vertex AI automatically installs packages listed in a requirements.txt file included in your Python package. This eliminates the need to build a custom container or manually manage installations, reducing cost and complexity for a simple CPU-based job.

Answer

Use a pre-built training container and include a setup.py file with install_requires; the container will execute setup.py to install dependencies.

Answer

Use a pre-built training container and pass a startup script via the 'command' argument that runs pip install for each package before training.

Answer

Create a custom Docker container that includes all dependencies, then specify it in the training job configuration.

Question 11

A team is training a PyTorch model on Vertex AI using a custom container and a multi-node GPU cluster. They want to reduce the total training time. Profiling shows that the GPU utilization is low and that each step waits for data loading from Cloud Storage. The dataset consists of many small JPEG files. What should they do to improve training throughput?

Accepted Answer

Convert the dataset to TFRecord or WebDataset shards and stream them with a parallel reader.. Low GPU utilization with many small files read from Cloud Storage indicates a data input bottleneck. Repacking small images into large shards and streaming them with a parallel reader removes per-file latency and lets each training worker sustain high read bandwidth. DataLoader tuning and local SSD copies do not eliminate the many-small-files overhead, and a relational database is the wrong storage system for bulk image reads.

Answer

Switch from Cloud Storage to a Cloud SQL database and query the images during training.

Answer

Copy the dataset to a local SSD on each node before training and read from that local path.

Answer

Increase the number of DataLoader worker processes and enable pinned memory and prefetching.

Question 12

An ML engineer is preparing to run a Vertex AI custom training job using a custom container. The container image is stored in Artifact Registry, and the training code reads a large dataset from a Cloud Storage bucket. The engineer wants to minimize the training time by ensuring the container can access the data quickly. Which of the following should the engineer do?

Accepted Answer

Use the Cloud Storage client library to read data directly from the bucket into memory, with parallel downloads.. The correct approach is to use the Cloud Storage client library with parallel downloads, as it provides high-throughput, low-latency access to data stored in Cloud Storage. This method is optimized for large datasets and integrates seamlessly with Vertex AI training. Other options introduce additional layers or tools that can slow down data access.

Answer

Enable the Cloud Storage API and use the gsutil command-line tool to download the data during training.

Answer

Mount the Cloud Storage bucket as a local file system using Cloud Storage FUSE in the training container.

Answer

Copy the dataset to the local SSD of the training VM before starting training.

Question 13

You are using Vertex AI to train a model on a large dataset. You want to reduce training costs by using preemptible VMs. Your training job is fault-tolerant and uses checkpointing. However, you notice that the job sometimes fails to complete because preemptible VMs are terminated. You need to ensure that the training job can resume from the last checkpoint and complete successfully. (Choose two.)

Accepted Answer

Configure the training job to write checkpoints to a Cloud Storage bucket, and ensure the training script loads the latest checkpoint on startup.. To successfully use preemptible VMs for fault-tolerant training, you must persist checkpoints to durable storage like Cloud Storage and configure the job to use preemptible VMs so Vertex AI can automatically restart it. These two steps ensure that training can resume from the last checkpoint and complete despite preemptions.

Answer

Implement a custom retry mechanism in the training script that catches termination signals and saves the model state before exiting.

Answer

Set the training job's maxWaitTime to a large value to allow the job to wait for preemptible VMs to become available.

Answer

Use a reduction server to handle the preemption and automatically restart the training job.

Question 14

You are scaling a prototype ML model to production on Vertex AI. The model is a TensorFlow model that you trained locally and saved in SavedModel format. You need to deploy it to an endpoint that can serve online predictions with low latency and support automatic scaling based on traffic. You also need to ensure the model can be updated without downtime. Which two actions should you take? (Choose two.)

Accepted Answer

Upload the SavedModel to Vertex AI Model Registry and deploy it to a Vertex AI Endpoint using a pre-built TensorFlow Serving container.. To deploy a TensorFlow SavedModel to Vertex AI for online predictions, you should upload it to Model Registry and deploy using a pre-built TensorFlow Serving container. Enabling automatic scaling with appropriate replica limits ensures low latency and high availability. These two actions together provide a production-ready, scalable, and updatable serving solution.

Answer

Export the model to ONNX format and deploy it using a pre-built ONNX Runtime container on Vertex AI Endpoints.

Answer

Use a custom container that loads the SavedModel and exposes a REST API, and deploy it to a Vertex AI Endpoint with a single replica to minimize latency.

Answer

Deploy the model to a Vertex AI Endpoint and manually manage traffic splitting by updating the endpoint configuration each time a new model version is deployed.

Question 15

You are training a large deep learning model on Vertex AI using a distributed strategy across multiple nodes with GPUs. You want to reduce training time and ensure efficient scaling. Which two practices should you implement? (Choose two.)

Accepted Answer

Use a synchronous training strategy with all-reduce for gradient synchronization, such as MirroredStrategy or MultiWorkerMirroredStrategy.. Synchronous all-reduce training with proportional batch size scaling are key practices for efficient distributed training on GPUs. They ensure stable convergence and balanced workloads across workers, reducing training time and improving scalability.

Answer

Enable gradient compression to reduce communication overhead between workers.

Answer

Use asynchronous training with parameter servers to allow workers to update parameters independently without waiting.

Answer

Store the dataset on a high-throughput shared file system like Filestore and have each worker read the entire dataset independently.