Courseiva

Google Professional Machine Learning Engineer (PMLE) — Questions 676–750

775 questions total · 11 pages · All types, answers revealed

Page 9

Page 10 of 11

Page 11
676
MCQhard

You are serving a model on a Vertex AI endpoint that requires a GPU. The model is used for interactive predictions with a strict latency SLO. You notice that during peak hours, some requests time out because the endpoint's autoscaler is slow to add GPU replicas. Which action should you take to meet the SLO?

A.Enable request batching on the endpoint to process multiple requests per replica.
B.Set a higher minimum replica count on the endpoint to keep more GPU replicas warm during peak hours.
C.Reduce the model's input size by truncating features to lower per-request compute.
D.Switch to a CPU-based machine type to avoid GPU provisioning delays.
AnswerB

Increasing the minimum replica count ensures that more GPU replicas are already running and ready to serve traffic before the peak arrives. Since GPU replicas take longer to start, pre-warming them avoids the delay caused by slow autoscaling. This directly addresses the timeout issue by providing sufficient capacity during peak hours without waiting for the autoscaler to react, helping to meet the strict latency SLO.

Why this answer

GPU replicas take longer to provision and initialize than CPU replicas, so autoscaling may not react quickly enough during sudden peaks. Setting a higher minimum replica count keeps additional GPU replicas warm and ready before demand spikes. This pre-provisioned capacity absorbs peak traffic immediately, preventing request queuing and timeouts.

It addresses the slow autoscaler response directly, ensuring the endpoint can meet its strict latency SLO during peak hours.

Exam trap

The trap here is assuming that batching or reducing input size solves timeout issues, when the real cause is insufficient warm GPU capacity during peak demand.

677
MCQmedium

An ML engineer is building a Vertex AI pipeline that trains a model and then evaluates it. The evaluation component must compare the new model's accuracy against a fixed threshold and, if the model passes, trigger a downstream deployment component. The engineer wants to avoid running the deployment component when the model fails. Which approach should the engineer use?

A.Define a condition on the deployment component using the evaluation metric output from the evaluation component.
B.Use a pipeline parameter to pass the evaluation result to the deployment component and let the deployment component decide whether to run.
C.Configure the evaluation component to raise an exception if the model fails, which will stop the entire pipeline before reaching the deployment component.
D.Create a separate pipeline that only contains the deployment component and trigger it manually after reviewing the evaluation results.
AnswerA

Vertex AI Pipelines supports conditional execution using the dsl.Condition construct. By referencing the evaluation metric output from the evaluation component, the engineer can conditionally execute the deployment component only when the metric meets the threshold. This ensures the deployment component is not run when the model fails, saving resources and aligning with the pipeline's logic.

Why this answer

Conditional execution in Vertex AI Pipelines is implemented using the dsl.Condition construct, which allows a component to run only if a specified condition is met. By referencing the evaluation metric output, the pipeline can automatically decide whether to deploy the model. This approach avoids running unnecessary components and keeps the pipeline logic self-contained.

Exam trap

The trap here is assuming that passing evaluation results as parameters or raising exceptions can control component execution, when in fact Vertex AI Pipelines requires explicit conditional constructs for branching.

678
MCQhard

An ML engineer is training a TensorFlow model on Vertex AI using a custom training job with a single worker and multiple GPUs. The training script uses tf.distribute.MirroredStrategy. After a few epochs, the job fails with a NCCL timeout error. The engineer confirms the GPUs are healthy and the batch size is reasonable. What should they do to resolve the error?

A.Increase the number of workers in the worker pool configuration to match the number of GPUs.
B.Set the environment variable NCCL_SOCKET_IFNAME to the correct network interface and ensure the container image includes a compatible NCCL version.
C.Set the environment variable NCCL_DEBUG=INFO and reduce the per-GPU batch size to lower memory pressure.
D.Ensure the training job is configured with a single replica and that the container sets the TF_CONFIG environment variable appropriately for a single-worker, multi-GPU setup.
AnswerB

NCCL timeouts on a single machine with multiple GPUs often occur when NCCL cannot determine the correct network interface or when there is a version mismatch between NCCL and the GPU driver or framework. Setting NCCL_SOCKET_IFNAME to the primary network interface (e.g., eth0) and using a pre-built container with a validated NCCL version ensures proper inter-GPU communication and resolves the timeout.

Why this answer

NCCL timeout errors in a single-worker, multi-GPU Vertex AI training job usually stem from NCCL being unable to select the correct network interface or from incompatible NCCL versions. Explicitly setting NCCL_SOCKET_IFNAME to the primary interface and using a container image with a validated NCCL build ensures that inter-GPU communication initializes correctly. MirroredStrategy does not require TF_CONFIG, so adding workers or TF_CONFIG would not help.

Exam trap

The trap here is assuming that NCCL timeout errors indicate a need for more workers or TF_CONFIG, when in a single-machine multi-GPU setup the issue is typically network interface selection or NCCL version compatibility.

679
Multi-Selectmedium

A media company is serving a video recommendation model on a Vertex AI Endpoint. The model receives a mix of requests: some require only a few features, while others require many features from a feature store. The team wants to reduce average latency and cost without retraining the model. Which TWO strategies should they use? (Choose two.)

Select 2 answers
A.Switch from online predictions to batch predictions for all requests.
B.Enable request batching on the endpoint to group multiple requests into a single prediction call.
C.Use a smaller machine type for the endpoint to reduce cost per replica.
D.Implement feature caching in the model container to avoid repeated feature store lookups for the same entities.
E.Increase the endpoint's maxReplicaCount to handle peak traffic.
AnswersB, D

Batching multiple requests into one prediction call can improve throughput and reduce per-request overhead, especially when the model can process a batch efficiently. This reduces average latency under load and can lower cost by using resources more effectively. It does not require retraining and is a serving-side optimization.

Why this answer

Request batching and feature caching are serving-side optimizations that reduce per-request overhead and repeated feature lookups. They lower average latency and can reduce cost by improving resource utilization, all without retraining the model. Other options either do not address the root causes or are unsuitable for real-time serving.

Exam trap

The trap here is assuming that scaling out with more replicas reduces average latency, when it primarily helps with peak load and may increase cost.

680
MCQmedium

A team uses Vertex AI Pipelines. They need to ensure that only certain team members can deploy models to production. What is the best approach?

A.Use Vertex AI Experiments to track models
B.Store model artifacts in a bucket with bucket-level permissions
C.Use IAM roles with custom permissions on the Vertex AI Model Registry
D.Create separate projects for dev and prod
AnswerC

Model Registry integrates with IAM to grant specific deployment permissions.

Why this answer

Vertex AI Model Registry supports IAM roles with custom permissions, allowing fine-grained access control over who can promote or deploy models to production. By assigning specific roles (e.g., `roles/aiplatform.modelDeployer`) to only authorized team members, you can restrict deployment actions while still permitting others to view or register models. This approach directly addresses the need to control production deployments without affecting other pipeline stages.

Exam trap

The trap here is that candidates often confuse artifact storage permissions (bucket-level IAM) with deployment permissions (model registry IAM), leading them to choose Option B, even though bucket permissions do not control the Vertex AI deployment API call.

How to eliminate wrong answers

Option A is wrong because Vertex AI Experiments is designed for tracking and comparing model training runs (e.g., hyperparameters, metrics), not for controlling access or permissions to deploy models. Option B is wrong because bucket-level permissions control access to the storage location of model artifacts, but they do not govern the deployment action itself within Vertex AI Pipelines; a user with bucket access could still lack deployment permissions, or vice versa. Option D is wrong because creating separate projects for dev and prod is an organizational boundary that can help with isolation, but it does not provide granular control over which specific team members can deploy within the same project; it also introduces overhead in managing multiple projects and does not leverage Vertex AI's native IAM capabilities for model registry operations.

681
MCQeasy

A machine learning engineer is building a pipeline with Vertex AI Pipelines and wants to pass a large dataset between components without copying it to the container's memory. What is the best practice for passing data between pipeline components?

A.Mount an NFS volume to all containers and share data via the filesystem.
B.Use Cloud Storage URIs (gs://) to point to the data location.
C.Serialize the dataset to JSON and include it as a pipeline parameter.
D.Use the importer component to load the data into the pipeline as an in-memory artifact.
AnswerB

Passing gs:// URIs means components exchange only small string references, so the large dataset stays in Cloud Storage and each container reads it directly. This satisfies the constraint of avoiding copying data into container memory between pipeline components.

Why this answer

Vertex AI Pipelines natively supports passing Cloud Storage URIs (gs://) as artifact references between components, allowing components to read the dataset directly from GCS without copying it into container memory. This avoids memory limits and enables efficient handling of large datasets by leveraging GCS's scalable object storage.

Exam trap

A common mistake in this exam is to think that large data must be passed as in-memory artifacts or serialized parameters, when the correct Vertex AI Pipelines pattern is to pass a Cloud Storage URI and let components read data lazily from GCS.

How to eliminate wrong answers

Option A is wrong because mounting an NFS volume introduces network filesystem latency, requires additional infrastructure setup, and is not a native or recommended pattern in Vertex AI Pipelines, which is designed for serverless, cloud-native artifact passing. Option C is wrong because serializing a large dataset to JSON and including it as a pipeline parameter would exceed the maximum parameter size limit (typically 512 KB in Vertex AI Pipelines) and would force the entire dataset into memory, defeating the purpose of avoiding memory copies. Option D is wrong because the importer component registers an external artifact (e.g., a GCS URI) into the pipeline's metadata store but does not load data into memory; the misconception is that it creates an in-memory artifact, whereas it merely creates a metadata reference.

682
MCQhard

Your organization uses Vertex AI Model Registry to manage models. A data scientist has trained a new model version and wants to ensure that only approved models are deployed to production. You need to implement a workflow where a model must be reviewed and approved by a designated approver before it can be deployed. What should you do?

A.Implement a CI/CD pipeline using Cloud Build that, upon a model version being tagged as 'approved', deploys it to an endpoint, and restrict the tagging permission to the approver.
B.Use Vertex AI Model Registry's built-in approval workflow by assigning the approver role to a user and setting the model version's state to 'Pending Approval'.
C.Create a Cloud Function that listens for new model versions, triggers a manual review via email, and upon approval, updates the model version's labels to indicate approval.
D.Restrict deployment permissions using IAM so that only the approver has the Vertex AI User role, and require the approver to manually deploy the model after review.
AnswerA

This approach uses a CI/CD pipeline to enforce that only models tagged as 'approved' are deployed. By restricting the tagging permission to the approver via IAM, you ensure that only authorized personnel can trigger deployment. Cloud Build automates the deployment, providing an auditable and repeatable process that integrates with Vertex AI Model Registry.

Why this answer

Enforcing an approval workflow requires a combination of access control and automation. By using a CI/CD pipeline that reacts to an 'approved' tag, and limiting who can apply that tag, you create a secure gate. This ensures that only reviewed models are deployed and provides an audit trail.

Native Model Registry lacks built-in approval, so custom logic is necessary.

Exam trap

The trap here is assuming that Vertex AI Model Registry includes a native approval workflow or that labels alone can securely gate deployments, when in fact you must combine IAM and external automation.

683
Multi-Selectmedium

You are preparing to scale a prototype ML model to production on Vertex AI. The model is trained with a custom training job, and you want to ensure that the training is reproducible and that you can compare different runs. Which two practices should you follow? (Choose two.)

Select 2 answers
A.Use Vertex AI Experiments to log parameters, metrics, and artifacts for each training run.
B.Specify a fixed random seed in your training code and record it along with the training configuration.
C.Always use the latest pre-built training container without pinning the version so that you get the newest features.
D.Store the trained model artifacts in a versioned location such as a Cloud Storage bucket with object versioning or a Vertex AI Model Registry entry.
E.Train on the full dataset without any sampling to ensure that all runs see the same data.
AnswersA, B

Vertex AI Experiments provides a structured way to track parameters, metrics, and artifacts across training runs, making it easy to compare runs and reproduce results. It integrates with Vertex AI Training and helps you maintain a record of what was used for each model, which is a key practice for scaling prototypes to production.

Why this answer

To make training reproducible and comparable, you should control randomness by setting and recording a fixed seed, and you should use Vertex AI Experiments to log parameters, metrics, and artifacts for each run. These two practices together let you reproduce a run and compare it with others. The other options either harm reproducibility by not pinning the environment or do not directly address run comparison.

Exam trap

The trap here is thinking that using the latest container or training on all data guarantees reproducibility, when the real keys are controlling randomness and systematically logging run metadata.

684
MCQmedium

You are scaling a prototype ML model to production on Vertex AI. The model is a TensorFlow model that you want to train on a large dataset using distributed training across multiple nodes. You need to minimize training time and ensure the job can recover from node failures. Which approach should you take?

A.Use Vertex AI Training with a custom training job that uses the TensorFlow DistributionStrategy with CentralStorageStrategy, and enable automatic restart of the job on failure without checkpointing.
B.Use Vertex AI Training with a custom training job that uses the TensorFlow DistributionStrategy with MirroredStrategy across multiple GPUs on a single node, and enable checkpointing to Cloud Storage.
C.Use Vertex AI Training with a custom training job that uses the TensorFlow DistributionStrategy with TPUStrategy on a TPU pod, and rely on TPU's built-in fault tolerance to handle node failures.
D.Use Vertex AI Training with a custom training job that uses the TensorFlow DistributionStrategy with MultiWorkerMirroredStrategy across multiple nodes, and configure the job to save checkpoints to Cloud Storage and resume from the latest checkpoint on failure.
AnswerD

MultiWorkerMirroredStrategy is designed for multi-node, multi-GPU training in TensorFlow. It synchronizes gradients across workers. Saving checkpoints to Cloud Storage and resuming from them allows the job to recover from node failures without restarting from scratch, minimizing training time and ensuring fault tolerance.

Why this answer

MultiWorkerMirroredStrategy enables multi-node, multi-GPU distributed training in TensorFlow. Combined with checkpointing to Cloud Storage and automatic resume, it provides both scalability and fault tolerance. This approach minimizes training time and ensures recovery from node failures.

Exam trap

The trap here is confusing single-node strategies like MirroredStrategy with multi-node strategies like MultiWorkerMirroredStrategy, or assuming that automatic restart without checkpointing is sufficient for fault tolerance.

685
MCQmedium

A machine learning engineer notices that the Vertex AI Prediction endpoint's error rate has increased over the past week. The model was retrained with new data and redeployed. Which step should the engineer take first to diagnose the issue?

A.Increase the number of replicas to reduce error rate.
B.Compare the input data distribution of recent requests to the training data distribution using Explainable AI.
C.Roll back to the previous model version immediately.
D.Check the Cloud Monitoring dashboard for latency and error codes, and review the model's prediction logs.
AnswerD

Cloud Monitoring exposes endpoint-level latency percentiles and HTTP error codes, while prediction logs capture request payloads and model responses. Together they isolate whether the regression stems from infrastructure, malformed inputs, or the retrained model itself — the fastest evidence-gathering step before altering the deployment.

Why this answer

The correct first step in any incident diagnosis is to gather observability data — Cloud Monitoring metrics (error rate, latency, error codes) and prediction logs — to characterize the failure before changing anything. This reveals whether errors are 4xx (bad input), 5xx (model/server), timeouts, or a specific code path, and whether the issue correlates with the redeployment. Only after this evidence is collected should the engineer consider rollback or data-distribution analysis.

Exam trap

PMLE often tests whether candidates jump to remediation (rollback, scaling) instead of the observability-first principle — the trap is treating 'roll back' as the safe default when the exam expects evidence gathering first.

How to eliminate wrong answers

Option A is wrong because scaling replicas addresses capacity/throughput problems, not error rates caused by a bad model or malformed inputs — it would mask or amplify the issue without diagnosis. Option C is wrong because rolling back immediately is a remediation action taken before root cause is known; it may fix the symptom but loses the diagnostic evidence and does not confirm the redeployment was the cause. Option B is wrong because Explainable AI feature-attribution comparison is a deeper drift-analysis step performed after basic monitoring confirms a data-related hypothesis — it is not the first diagnostic action.

686
Multi-Selecteasy

Which TWO practices help ensure reproducible ML experiments?

Select 2 answers
A.Store all artifacts in a temporary bucket
B.Use a random seed for each run
C.Use Vertex AI Experiments to track parameters and metrics
D.Version control training code with Cloud Source Repositories
E.Use preemptible VMs
AnswersC, D

Experiments record the exact configuration and results.

Why this answer

Vertex AI Experiments automatically logs parameters, metrics, and artifacts for each run, creating a complete lineage that enables exact reproduction of results. By tracking these details alongside the code version, you can recreate the exact environment and configuration that produced a given outcome, which is essential for reproducibility.

Exam trap

Google Cloud often tests the distinction between practices that improve reproducibility (like tracking parameters and versioning code) versus practices that improve cost efficiency or speed (like using preemptible VMs or temporary storage), leading candidates to conflate operational convenience with scientific reproducibility.

687
MCQmedium

A company is training a large neural network on Vertex AI and training jobs keep failing with 'Out of memory' errors. The VM uses a standard n1-standard-4 machine with 15 GB RAM. Which action should they take first?

A.Use a larger machine type like n1-standard-16
B.Reduce the batch size in the training script
C.Enable distributed training across multiple VMs
D.Switch the training to CPU only
AnswerB

Out-of-memory errors arise when the training batch exceeds available GPU or host RAM. Reducing batch size lowers peak memory per step, allowing the model to fit within the n1-standard-4's 15 GB. This is the fastest, least disruptive first remedy before considering larger machines.

Why this answer

The 'Out of memory' error on a n1-standard-4 VM (15 GB RAM) indicates the model's memory footprint exceeds available RAM. Reducing the batch size directly decreases the memory required for storing intermediate activations and gradients during training, which is the most immediate and cost-effective fix without changing the underlying infrastructure.

Exam trap

The trap here is that candidates often jump to scaling up infrastructure (larger machine or distributed training) instead of first tuning the training hyperparameter (batch size) that directly controls memory consumption, which is the simplest and most cost-effective fix.

How to eliminate wrong answers

Option A is wrong because upgrading to a larger machine type (e.g., n1-standard-16) increases cost and may still fail if the memory issue is due to a batch size that is too large for the model; it does not address the root cause of memory pressure. Option C is wrong because enabling distributed training across multiple VMs introduces network overhead and synchronization complexity (e.g., using all-reduce with NCCL) and does not reduce per-VM memory consumption; it may even increase memory usage due to gradient accumulation buffers. Option D is wrong because switching to CPU only typically uses more memory for the same batch size (CPU memory is not the bottleneck here; GPU memory is not even mentioned, and the error is on a standard VM without GPUs), and it would dramatically slow training without solving the OOM issue.

688
MCQhard

A fraud-detection model is deployed on a Vertex AI endpoint and must respond within 30 ms for 95% of requests. During testing, the team sees that p95 latency is dominated by feature retrieval from an external online store, not by model inference. They want to reduce latency without retraining the model. What should they do first?

A.Enable request-response logging on the endpoint to identify which feature lookups are slow, then retrain the model with fewer features.
B.Switch the endpoint to batch prediction mode so requests are grouped and feature lookups are amortized.
C.Increase the endpoint's maxReplicaCount so more replicas can handle feature lookups in parallel.
D.Co-locate the feature values with the model by using a low-latency in-memory feature store or embedding the features in the request path.
AnswerD

When feature retrieval dominates p95 latency, the most direct fix is to remove or shorten that network hop. Serving features from an in-memory store or including them in the request payload eliminates the external round trip and keeps the model's inference time as the only major component. This aligns with the no-retraining constraint.

Why this answer

The p95 latency is dominated by an external online feature store, so the serving architecture, not the model or replica count, is the limiting factor. Bringing features into the model's process via an in-memory store or passing them in the request removes the network round trip and directly attacks the dominant latency component.

Exam trap

The trap here is defaulting to horizontal scaling whenever latency is high, when the real issue is per-request external dependency latency that replication cannot fix.

689
MCQmedium

A retail company wants to build a customer churn prediction model using BigQuery ML. The data is stored in BigQuery tables and includes customer demographics, purchase history, and support interactions. The data scientist wants to experiment with different model types quickly without moving data to another environment. Which approach should they use?

A.Use Cloud Composer to orchestrate a custom training pipeline on Vertex AI.
B.Use AI Platform Notebooks with pandas and scikit-learn.
C.Use BigQuery ML to create and evaluate models directly in BigQuery.
D.Export the data to Cloud Storage and use Vertex AI AutoML Tables.
AnswerC

BigQuery ML trains and evaluates models using SQL directly against the existing BigQuery tables, so no data movement or separate serving environment is needed. This satisfies the requirement to experiment with multiple model types quickly in place.

Why this answer

BigQuery ML (BQML) allows data scientists to create, train, and evaluate machine learning models directly in BigQuery using SQL, without moving data to another environment. This approach supports rapid experimentation with various model types (e.g., logistic regression, boosted trees, deep neural networks) and is ideal for the stated requirement of quick iteration while keeping data in place.

Exam trap

Google Cloud often tests the candidate's ability to recognize that BigQuery ML is purpose-built for low-code, in-database ML experimentation, and the trap here is assuming that more complex or external tools (like Vertex AI or Cloud Composer) are necessary when the simpler, integrated solution suffices.

How to eliminate wrong answers

Option A is wrong because Cloud Composer is an orchestration tool for workflows, not a direct model training environment; using it to build a custom pipeline on Vertex AI would require moving data and add unnecessary complexity. Option B is wrong because AI Platform Notebooks with pandas and scikit-learn require exporting data from BigQuery to a Python environment, violating the requirement to keep data in BigQuery. Option D is wrong because exporting data to Cloud Storage for Vertex AI AutoML Tables introduces data movement and latency, contradicting the need for quick experimentation without moving data.

690
MCQhard

A team is using Vertex AI Pipelines to orchestrate a multi-step ML workflow. They need to pass a large dataset (several terabytes) between two components: a preprocessing component and a training component. The preprocessing component outputs a preprocessed dataset that the training component consumes. The team wants to minimize data transfer time and cost. What is the most efficient way to pass the data between these components?

A.Mount a Filestore instance as a shared volume to both components and write the data there.
B.Use a `Dataset` artifact to pass the data, and configure the artifact to store the data in the pipeline's metadata store.
C.Have the preprocessing component output the data as a base64-encoded string parameter, and pass it to the training component.
D.Write the preprocessed data to a Cloud Storage bucket and pass the bucket URI as an output parameter to the training component.
AnswerD

Passing a Cloud Storage URI as an output parameter is the standard and most efficient way to share large datasets between components in Vertex AI Pipelines. The training component can directly read from Cloud Storage, avoiding unnecessary data movement and leveraging Google's high-bandwidth network.

Why this answer

For large datasets, the best practice is to write data to Cloud Storage and pass the URI as a parameter. This avoids moving data through the pipeline's control plane and leverages Cloud Storage's scalability and high throughput. The training component can then read directly from the bucket.

Exam trap

The trap here is thinking that the pipeline must pass the actual data between components, when it should only pass references to data stored in Cloud Storage.

691
MCQeasy

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?

A.Cloud Dataflow with sliding windows
B.Cloud Pub/Sub for windowing logic
C.BigQuery scheduled queries
D.Cloud Functions with Pub/Sub triggers
AnswerA

Cloud Dataflow supports sliding windows (e.g., via the SlidingWindows transform in Beam), making it suitable for computing aggregates over overlapping time intervals. The option text says 'fixed windows', but the service itself can handle sliding windows.

Why this answer

Cloud Dataflow, based on Apache Beam, natively supports sliding time windows, making it the appropriate service for computing aggregate features over overlapping time intervals from streaming data. Fixed windows alone would not satisfy the sliding-window requirement, and the other services lack native sliding window aggregation capabilities.

Exam trap

Candidates might confuse fixed windows with sliding windows. Cloud Dataflow supports both, but to meet the requirement the option must explicitly specify sliding windows, not fixed windows.

How to eliminate wrong answers

Option B is wrong because Cloud Pub/Sub is a messaging service that handles event ingestion and delivery, not windowing logic or stateful aggregation; it has no built-in capability to compute sliding window aggregates. Option C is wrong because BigQuery scheduled queries operate on batch data in tables, not on streaming data in real time, and they lack the low-latency, per-event windowing needed for a streaming feature pipeline. Option D is wrong because Cloud Functions with Pub/Sub triggers are stateless and ephemeral, with a maximum timeout of 9 minutes (or 60 minutes with 2nd gen), making them unsuitable for maintaining sliding window state or performing continuous aggregation over streaming data.

692
MCQeasy

A retail company wants to forecast daily sales for the next 30 days based on historical sales data. They have two years of daily sales records with no missing values. They want to use a low-code solution on Google Cloud that automatically handles seasonality and trends. Which service should they use?

A.Cloud Dataflow with a sliding window aggregation
B.Vertex AI Forecasting with a custom training container
C.BigQuery ML with the ARIMA_PLUS model
D.AutoML Tables with a regression target
AnswerC

BigQuery ML's ARIMA_PLUS model is specifically designed for time series forecasting. It automatically handles seasonality, trends, and holiday effects, and can generate forecasts for multiple time steps. It requires only SQL to train and predict, making it a low-code solution. Given the clean daily sales data, ARIMA_PLUS is well-suited to produce accurate 30-day forecasts without manual feature engineering.

Why this answer

BigQuery ML's ARIMA_PLUS is the correct choice because it is a low-code, SQL-based time series forecasting model that automatically handles seasonality, trends, and holidays. It is designed for exactly this type of scenario: forecasting future values from historical time series data. Other options either require manual feature engineering, are not forecasting-specific, or involve significant coding, making ARIMA_PLUS the most efficient and appropriate solution.

Exam trap

The trap here is confusing general-purpose regression models with specialized time series models, overlooking that only ARIMA_PLUS automatically handles temporal patterns like seasonality.

693
MCQhard

An organization has multiple ML pipelines running on Vertex AI. They want to centralize monitoring and alerting for pipeline failures, including root cause analysis. Which combination of services should they use?

A.Cloud Trace + Cloud Debugger
B.Cloud Logging + Cloud Monitoring + Error Reporting
C.Cloud Operations for GKE + Stackdriver
D.Cloud Audit Logs + Cloud Functions
AnswerB

Cloud Logging captures pipeline and component logs, Cloud Monitoring surfaces metrics and fires alerts on failures, and Error Reporting aggregates and groups exceptions for root cause analysis. Together they satisfy the centralised monitoring, alerting and diagnosis constraint across multiple Vertex AI pipelines.

Why this answer

Cloud Logging captures pipeline execution logs, Cloud Monitoring provides metrics and alerting on pipeline failures, and Error Reporting aggregates and analyzes errors with stack traces for root cause analysis. Together, they form a centralized observability stack that meets the requirement for monitoring, alerting, and root cause analysis of ML pipeline failures on Vertex AI.

Exam trap

The trap here is that candidates confuse Cloud Trace and Cloud Debugger (debugging tools) with the monitoring and logging services needed for failure detection and root cause analysis, or mistakenly think Cloud Audit Logs (compliance logs) are sufficient for pipeline error monitoring.

How to eliminate wrong answers

Option A is wrong because Cloud Trace is designed for latency analysis of distributed systems, not for monitoring pipeline failures or root cause analysis of errors, and Cloud Debugger inspects live application state without capturing historical failure data. Option C is wrong because Cloud Operations for GKE is specific to Google Kubernetes Engine workloads, not Vertex AI pipelines, and Stackdriver is the legacy name for what is now Cloud Operations, making this option outdated and misaligned with Vertex AI. Option D is wrong because Cloud Audit Logs record administrative actions and access logs, not pipeline execution errors or failures, and Cloud Functions alone cannot provide the centralized monitoring, alerting, and error analysis required.

694
Multi-Selecthard

A team is troubleshooting a Vertex AI Pipelines run that keeps failing at the model evaluation step. The pipeline includes steps: data preprocessing, training, evaluation, and deployment. Which THREE actions should they take to diagnose the issue?

Select 3 answers
A.Verify that the training step output is correctly linked as input to evaluation.
B.Run the evaluation code locally with the same input data.
C.Increase the memory of the evaluation step's machine.
D.Check the logs of the evaluation step in Cloud Logging.
E.Replace the evaluation step with a Vertex AI Model Evaluation service.
AnswersA, B, D

Evaluation fails when its input artifact is missing or malformed. Confirming the training step's output model is correctly wired as the evaluation step's input verifies the pipeline graph passes a valid artifact, ruling out a broken dependency before debugging the code itself.

Why this answer

Option A is correct because Vertex AI Pipelines passes data between steps through declared input/output artifacts, so if the training step's output artifact is not correctly wired as the evaluation step's input, the evaluation component will fail from missing or malformed input. Option B is correct because running the evaluation code locally with the same input data isolates the component logic from the pipeline orchestration, quickly revealing whether the failure is in the code or in the pipeline configuration. Option D is correct because Cloud Logging captures the evaluation step's container stdout/stderr and error messages, which is the primary way to see the actual exception raised during the pipeline run.

Option C is not appropriate because increasing memory is a speculative resource change that does not diagnose the root cause and would only help if an out-of-memory error were already confirmed. Option E is not appropriate because swapping the evaluation step for Vertex AI Model Evaluation changes the pipeline rather than diagnosing the existing failure, and it may not even be compatible with the current pipeline's inputs and outputs.

Exam trap

Google Cloud often tests the misconception that resource scaling (Option C) is the first diagnostic step for pipeline failures, when in reality, most failures in Vertex AI Pipelines stem from misconfigured artifact passing or code errors, not hardware limits.

695
MCQmedium

You are using Vertex AI Matching Engine for similarity search. Your index has 10 million embeddings of 512 dimensions. The query latency requirement is under 10ms for 99th percentile. Which index type should you choose?

A.Brute-force index with cosine distance.
B.Approximate Nearest Neighbor (ANN) index using the ScaNN algorithm.
C.A custom distance-based index using Cloud SQL.
D.A tree-based index from scikit-learn deployed as a custom container.
AnswerB

ScaNN's approximate nearest neighbour index partitions and quantises vectors, avoiding exhaustive distance computation across all 10 million embeddings. This keeps 99th-percentile query latency under 10ms, which exact brute-force search could not achieve at this scale.

Why this answer

The ScaNN (Scalable Nearest Neighbors) algorithm is specifically designed for high-dimensional, large-scale similarity search with strict latency requirements. With 10 million 512-dimensional embeddings, an ANN index like ScaNN can achieve sub-10ms query latency at the 99th percentile by trading a small amount of recall for dramatic speed improvements, which is exactly what Vertex AI Matching Engine optimizes for.

Exam trap

The trap here is that candidates assume brute-force is the only 'accurate' option and underestimate how severely the curse of dimensionality degrades tree-based and exact methods at 512 dimensions, leading them to pick A or D despite the explicit latency constraint.

How to eliminate wrong answers

Option A is wrong because a brute-force index computes exact distances against all 10 million embeddings, which for 512-dimensional vectors would require O(10M * 512) operations per query, far exceeding the 10ms latency target even with optimized hardware. Option C is wrong because Cloud SQL is a relational database not designed for vector similarity search; it lacks native support for high-dimensional distance computations and would require full table scans, making sub-10ms latency impossible at this scale. Option D is wrong because scikit-learn's tree-based indices (e.g., KD-Tree, Ball Tree) degrade to near-linear search in high dimensions (curse of dimensionality), performing no better than brute force for 512 dimensions, and deploying as a custom container adds unnecessary overhead without addressing the fundamental algorithmic limitation.

696
MCQmedium

You are using Vertex AI Vector Search with an approximate nearest neighbor index. You need to update the index with new data every hour. The updates must be available for queries immediately. Which update method should you use?

A.Recreate the index every hour using a scheduled job.
B.Batch update by creating a new index and deploying it.
C.Streaming updates using the streaming API.
D.Use a brute-force index that supports real-time updates.
AnswerC

Streaming updates via the streaming API mutate the deployed index in place, so newly added or removed datapoints become queryable within seconds. This satisfies the hourly refresh with immediate query visibility, unlike batch rebuilds that require reindexing and redeployment.

Why this answer

Vertex AI Vector Search supports streaming updates via its streaming API, which allows you to insert, update, or delete vectors in real time. This ensures that new data is immediately available for approximate nearest neighbor (ANN) queries without requiring index recreation or redeployment, meeting the requirement for hourly updates with instant query availability.

Exam trap

A common misconception is that updating an approximate nearest neighbor (ANN) index requires recreating and redeploying it. However, Vertex AI Vector Search provides a streaming API that enables real-time insert, update, and delete operations, making new data immediately available for queries without the overhead of full index rebuilds.

How to eliminate wrong answers

Option A is wrong because recreating the entire index every hour is inefficient and introduces downtime during the rebuild process, failing the requirement for immediate query availability. Option B is wrong because batch updating by creating a new index and deploying it involves a delay for building and deploying the index, so updates are not available immediately for queries. Option D is wrong because Vertex AI Vector Search does not offer a brute-force index that supports real-time updates; brute-force indices are typically used for exact nearest neighbor search and are not designed for real-time streaming updates in this service.

697
MCQmedium

A healthcare provider needs to extract structured information from incoming PDF forms (e.g., patient intake forms). They want to automate data extraction without writing custom models. Which Google Cloud service should they use?

A.Document AI with a form parser processor
B.Natural Language API for entity extraction
C.Vision API
D.AutoML Vision for object detection
AnswerA

Document AI's form parser processor is a pretrained model that extracts key-value pairs and tables from PDFs, requiring no custom model training. This directly satisfies the constraint of automating structured extraction from intake forms without writing custom models.

Why this answer

Document AI with a form parser processor is the correct choice because it is purpose-built for extracting structured data from PDF forms, including key-value pairs and tables, without requiring custom model development. It uses pre-trained models specifically for form understanding, making it ideal for automating intake form processing.

Exam trap

A common pitfall is choosing the Vision API for form parsing because it performs OCR, but it lacks the specialized form-field extraction capabilities of Document AI, which is designed specifically for structured data extraction from forms.

How to eliminate wrong answers

Option B is wrong because Natural Language API is designed for extracting entities and sentiment from unstructured text, not for parsing structured form fields from PDF documents. Option C is wrong because Vision API provides optical character recognition (OCR) to extract raw text from images but lacks the form-specific parsing logic to identify key-value pairs and table structures. Option D is wrong because AutoML Vision for object detection is used for identifying objects within images, not for extracting structured data from forms.

698
Matchingmedium

Match each ML pipeline component to its description.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts
Matches

Production ML pipeline framework by Google

ML toolkit for Kubernetes-based workflows

Unified stream and batch data processing service

Managed Apache Airflow workflow orchestration

Serverless ML pipeline orchestration on Vertex AI

Why these pairings

The correct matches are: Data ingestion → Collecting and importing raw data from various sources. Data validation → Checking data quality, integrity, and schema compliance. Feature engineering → Transforming raw data into features that improve model performance.

The remaining options are incorrect: Model training is not about assessing model performance (that's evaluation); Model evaluation is not about deploying a model (that's deployment); Model deployment is not about transforming raw data into features (that's feature engineering).

Exam trap

A common trap is confusing model training with model evaluation. Training is the process of learning model parameters, while evaluation measures performance using metrics.

699
MCQhard

You are using Vertex AI Vector Search for a product recommendation system. Your index is updated with new embeddings every hour. To minimize query latency while keeping the index fresh, what should you do?

A.Use streaming updates to insert new embeddings into the deployed index.
B.Rebuild the entire index hourly as a batch job and redeploy it.
C.Create a new index each hour and use traffic splitting to gradually shift traffic.
D.Use a brute-force index instead of ANN to ensure accuracy after updates.
AnswerA

Streaming updates let Vector Search mutate the deployed index in place as new embeddings arrive, so hourly refreshes avoid the rebuild-and-redeploy cycle that batch updates require. This keeps the index fresh without taking it offline, directly satisfying the low-latency, hourly-freshness constraint in the stem.

Why this answer

Vertex AI Vector Search supports streaming updates that let you insert, update, or delete datapoints in a deployed index without rebuilding it, so queries stay low-latency while the index remains fresh. This is the intended mechanism for near-real-time freshness with minimal disruption. Batch rebuilds and redeployments cause downtime and latency spikes, which the question explicitly asks to avoid.

Exam trap

PMLE often tests the trade-off between index freshness and query latency, and candidates wrongly assume a full rebuild is required for updates, missing the streaming update capability.

How to eliminate wrong answers

Option B is wrong because rebuilding the entire index hourly and redeploying is expensive, slow, and causes query unavailability or latency spikes during the swap, defeating the goal of minimizing latency. Option C is wrong because creating a new index hourly with traffic splitting adds operational overhead and still requires full index builds, and traffic splitting is for model/index rollout, not hourly freshness. Option D is wrong because brute-force (exact) search scales poorly and dramatically increases query latency, the opposite of the requirement.

700
MCQmedium

You are training a model on Vertex AI using a custom training job. The training data is stored in a Cloud Storage bucket in the us-central1 region, and the training job runs in the us-central1 region. You notice that the training job takes significantly longer than expected due to data loading. You want to improve data loading performance without changing the model architecture. What should you do?

A.Copy the training data to the local SSD of the training VM before training begins, and read from there.
B.Convert the training data to TFRecord format and use the tf.data.TFRecordDataset with parallel interleave and prefetching.
C.Enable streaming reads from Cloud Storage by using the tf.data.experimental.make_csv_dataset function with a large buffer size.
D.Use the Vertex AI Training reduction server to accelerate data loading.
AnswerB

TFRecord is a binary format that is more efficient to read than many small files. Using tf.data.TFRecordDataset with parallel interleave and prefetching allows overlapping data loading with model training, significantly improving throughput. This is a recommended practice for optimizing input pipelines on Vertex AI, especially when data is stored in Cloud Storage.

Why this answer

Converting data to TFRecord and using tf.data with parallel interleave and prefetching optimizes the input pipeline by reducing the number of read operations and overlapping data loading with computation. This is a standard best practice for improving training performance on Vertex AI when data is in Cloud Storage.

Exam trap

The trap here is assuming that simply increasing buffer size or copying data locally will solve the data loading bottleneck without addressing the format and parallelization of reads.

701
MCQmedium

You have a TensorFlow model that you want to deploy on Vertex AI for online prediction. The model requires a custom preprocessing step that transforms raw input features into the format expected by the model. You need to ensure that the same preprocessing is applied both during training and serving, and that it is maintained as part of the model artifact. What should you do?

A.Write a separate Python script for preprocessing and include it in the custom container for both training and serving.
B.Use Vertex AI Feature Store to store preprocessed features and serve them during prediction.
C.Perform preprocessing in a Cloud Function that triggers before sending data to the Vertex AI endpoint.
D.Implement the preprocessing as a TensorFlow Transform (tf.Transform) preprocessing function and attach it to the model using a SavedModel signature.
AnswerD

tf.Transform allows you to define preprocessing as part of the TensorFlow graph, ensuring consistency between training and serving. By exporting the transform function with the SavedModel, the preprocessing is encapsulated in the model artifact and automatically applied during online prediction. This is the recommended approach for maintaining preprocessing consistency.

Why this answer

Using tf.Transform to define preprocessing and attaching it to the SavedModel ensures that the same transformation is applied during both training and serving. The preprocessing becomes part of the model artifact, simplifying deployment and maintenance. Other options either risk inconsistency or add unnecessary complexity.

Exam trap

The trap here is thinking that any shared code or external service can guarantee consistency, when the most reliable method is to embed preprocessing directly into the model artifact.

702
MCQhard

An ML engineer manages a Vertex AI Endpoint serving a fraud detection model. Compliance requires that every prediction be logged with its input features for audit, but the team also wants to minimize storage costs. They decide to enable request-response logging on the endpoint. Which configuration should they use to meet both requirements?

A.Enable request-response logging with a sampling rate of 0.1 and send logs to Cloud Logging.
B.Enable request-response logging with a sampling rate of 1.0 and send logs to Cloud Logging with a default retention of 30 days.
C.Enable request-response logging with a sampling rate of 0.5 and configure a BigQuery sink for analysis.
D.Enable request-response logging with a sampling rate of 1.0 and set the logging destination to a Cloud Storage bucket with a lifecycle policy to delete objects after 30 days.
AnswerD

A sampling rate of 1.0 logs every prediction, which satisfies the audit requirement that every prediction be recorded with its input features. Directing logs to Cloud Storage and applying a lifecycle policy to delete after 30 days controls storage costs while meeting the retention need. This combination ensures completeness for compliance and cost efficiency, unlike sampling or shorter retention that would violate the audit mandate.

Why this answer

Compliance requires that every prediction be logged with its input features, so the sampling rate must be 1.0. To minimize storage costs, logs should be stored in a cost-effective location such as Cloud Storage, with a lifecycle policy to delete after the required retention period. Sampling below 1.0 or using higher-cost logging services would either miss predictions or increase expenses, failing one of the stated requirements.

Exam trap

The trap here is focusing on sampling rates for cost savings when the compliance requirement explicitly demands that every prediction be logged, making any sampling below full capture incorrect.

703
MCQeasy

Refer to the exhibit. A team deploys a model using Cloud Run. They notice that after scaling up, the new instances take about 90 seconds to become ready and serve requests. They want to reduce this startup time. Which configuration change is most likely to help?

A.Reduce the startupProbe initialDelaySeconds to 30
B.Change the container image to use a smaller base image
C.Reduce the memory limit to 4Gi
D.Increase the containerConcurrency to 100
AnswerB

A smaller base image reduces the bytes pulled and unpacked at instance start, shortening container initialisation before the model loads. Since the 90-second delay occurs during scale-up readiness, shrinking the image directly targets that startup time.

Why this answer

Changing the container image to use a smaller base image reduces the image size and the number of layers that must be pulled and unpacked, which directly reduces container startup time on new Cloud Run instances. A smaller image means less data to download and less filesystem work before the application can start, addressing the 90-second startup delay. This is the most likely configuration change to improve cold start performance.

Exam trap

PMLE often tests whether candidates confuse probe timing adjustments with actual startup performance improvements, leading them to pick the startupProbe change instead of reducing image size.

How to eliminate wrong answers

Option A is wrong because reducing startupProbe initialDelaySeconds only changes when the probe begins checking; it does not make the application start faster and could cause premature failures if the app is not ready. Option C is wrong because reducing the memory limit to 4Gi constrains resources and may cause out-of-memory errors or slower startup, not faster readiness. Option D is wrong because increasing containerConcurrency controls how many requests a single instance handles concurrently; it does not reduce the time for a new instance to become ready and may increase per-instance load.

704
MCQmedium

A retail company wants to forecast monthly sales for each of its 500 stores using historical sales data. They have two years of daily sales data per store and want to use BigQuery ML to build a forecasting model. They need to account for seasonality and trends. Which BigQuery ML model type should they use?

A.Linear regression
B.Logistic regression
C.K-means clustering
D.ARIMA_PLUS
AnswerD

ARIMA_PLUS is a built-in BigQuery ML model for time series forecasting that automatically handles seasonality, trends, and holidays. It is designed for forecasting multiple time series, such as sales per store, and can process large datasets. It provides explainable forecasts and requires only the time series identifier, timestamp, and value columns. This makes it ideal for the retail company's monthly sales forecasting across many stores.

Why this answer

ARIMA_PLUS is specifically designed for time series forecasting in BigQuery ML. It automatically detects and models seasonality, trends, and holidays, which are critical for retail sales data. It supports multiple time series, allowing per-store forecasts.

This low-code solution requires minimal feature engineering and provides accurate, explainable results, making it the right choice for the company's needs.

Exam trap

The trap here is using a general regression model like linear regression for time series data without accounting for seasonality.

705
MCQmedium

A retail company wants to generate product recommendations on their website using Google Cloud. They have historical transaction data and need a managed service that provides personalized recommendations like 'frequently bought together'. Which service should they use?

A.Recommendations AI
B.BigQuery ML
C.Vertex AI Prediction
D.AutoML Tables
AnswerA

Recommendations AI is a managed Google Cloud service that ingests historical transaction data and produces personalised product recommendations such as 'frequently bought together', satisfying the managed-service and recommendation-quality constraints. It removes the need to build and train custom recommendation models.

Why this answer

Recommendations AI is a purpose-built managed service on Google Cloud designed for retail recommendation use cases, including 'frequently bought together', 'recommended for you', and 'others you may like'. It ingests historical transaction and catalog data, trains retail-specific models automatically, and serves personalized recommendations via API without requiring ML expertise. This directly matches the requirement for a managed service providing personalized product recommendations.

Exam trap

The trap here is confusing general-purpose ML services (BigQuery ML, Vertex AI, AutoML) with a purpose-built managed recommendation service — candidates who default to 'Vertex AI for everything ML' miss that Recommendations AI is the retail-specific managed offering.

How to eliminate wrong answers

Option B is wrong because BigQuery ML lets you build and run ML models using SQL inside BigQuery, but it is not a managed recommendation service — you would have to design, train, and serve the recommender yourself. Option C is wrong because Vertex AI Prediction is only a model-serving endpoint; it hosts models but does not provide retail recommendation logic, training pipelines, or pre-built recommendation types. Option D is wrong because AutoML Tables is a general tabular AutoML trainer, not a recommendation-specific managed service, and it lacks the retail recommendation objectives and serving API that Recommendations AI provides.

706
MCQmedium

An organisation uses Delta Lake on Dataproc to manage a data lake for ML training. They need ACID transactions for concurrent reads and writes. Which file format does Delta Lake use as the underlying storage?

A.Apache Parquet
B.Apache ORC
C.CSV
D.Apache Avro
AnswerA

Delta Lake stores its data files as Apache Parquet, layering a transaction log over them to provide ACID guarantees. Parquet supplies the columnar, compressed storage; the Delta log records commits, enabling concurrent reads and writes without corrupting the underlying Parquet files.

Why this answer

Delta Lake stores its data files in Apache Parquet format and layers a transaction log (the _delta_log directory) on top to provide ACID guarantees, schema enforcement, and time travel. Parquet's columnar layout is ideal for ML workloads because it enables efficient column pruning and predicate pushdown during feature engineering. The Delta transaction log, not the file format itself, is what delivers the ACID properties.

Exam trap

PMLE often tests whether candidates know that Delta Lake's ACID properties come from the transaction log layer, not from Parquet itself — candidates may pick ORC or Avro thinking the format provides ACID, when in fact Parquet is the storage and the log provides the guarantees.

How to eliminate wrong answers

Option B is wrong because Apache ORC is a columnar format used primarily in the Hive/Spark ecosystem but is not the underlying storage format for Delta Lake — Delta is built on Parquet. Option C is wrong because CSV is a row-based, schema-less text format with no columnar compression or predicate pushdown, and it cannot support ACID transactions. Option D is wrong because Apache Avro is a row-based serialization format used for streaming and schema evolution in Kafka/Hadoop pipelines, not the columnar storage layer Delta Lake uses.

707
MCQmedium

An e-commerce company uses a recommendation model deployed on Vertex AI Endpoints. The model's latency increases gradually over two weeks, causing timeouts. The model is served using a custom container. What is the most likely root cause and corrective action?

A.The model is receiving more traffic; scale the number of replicas.
B.The custom container has a memory leak; implement memory monitoring and set container resource limits.
C.The Vertex AI endpoint has changed its URL; update the client application.
D.The model file size has grown due to feature engineering; reduce feature count.
AnswerB

A memory leak in the custom container causes gradual resource exhaustion, steadily raising latency until timeouts occur. Monitoring memory usage and applying container resource limits detects the leak and prevents it from degrading the endpoint, directly addressing the two-week latency creep described.

Why this answer

A gradual increase in latency over two weeks, without a sudden spike, strongly indicates a memory leak in the custom container. As the leak accumulates, the container's garbage collection becomes less effective, leading to increased GC pauses and eventual timeouts. Setting resource limits and monitoring memory usage can prevent the container from exhausting host memory and causing performance degradation.

Exam trap

The trap here is that candidates confuse a gradual latency increase with a traffic scaling issue (Option A), but the slow, steady degradation over weeks is the hallmark of a resource leak, not a demand spike.

How to eliminate wrong answers

Option A is wrong because a gradual latency increase over two weeks is not characteristic of a sudden traffic surge; traffic spikes would cause immediate latency jumps, not a slow creep. Option C is wrong because Vertex AI endpoint URLs are stable and do not change over time; a URL change would cause immediate 404 errors, not gradual latency increases. Option D is wrong because model file size does not change dynamically during serving; feature engineering changes would require a new model deployment, not cause a gradual latency increase in an already deployed model.

708
MCQmedium

A team deployed a model to a Vertex AI Endpoint and enabled Vertex AI Model Monitoring for skew detection. They notice that training-serving skew metrics are only produced when the endpoint receives traffic, but they want to ensure the skew is computed correctly even during periods of low traffic. Which configuration should they adjust to ensure skew detection remains statistically valid without generating excessive false positives?

A.Enable explainable AI on the endpoint and use feature attributions to detect skew.
B.Adjust the drift threshold to a higher value and reduce the sampling rate to 0.1.
C.Configure a longer monitoring window (e.g., daily) and set a minimum sample size for the monitoring job.
D.Increase the monitoring frequency to every 10 minutes and set the sampling rate to 1.0.
AnswerC

Vertex AI Model Monitoring allows you to set the monitoring window and a minimum number of samples required before computing skew. By using a longer window, you accumulate more instances, improving statistical power. Setting a minimum sample size prevents the job from running on insufficient data, thus reducing false positives and ensuring valid skew detection even with low traffic.

Why this answer

Training-serving skew detection in Vertex AI Model Monitoring relies on comparing distributions of serving data to the training baseline. With low traffic, short windows yield too few samples, making skew estimates noisy. Using a longer window and enforcing a minimum sample size ensures enough data for statistically meaningful comparisons, reducing false alerts while maintaining detection capability.

Exam trap

The trap here is assuming that increasing sampling rate or frequency will fix low-traffic skew detection, when the real issue is insufficient samples per window.

709
Matchingmedium

Match each Google Cloud storage option to its best use case.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts
Matches

Unstructured object storage for any type of data

NoSQL wide-column database for low-latency, high-throughput

Serverless data warehouse for analytics at scale

Relational database for OLTP workloads

NoSQL document database for mobile/web apps

Why these pairings

Correct matches: A (Cloud Storage for unstructured data), C (Bigtable for low-latency analytical workloads), E (BigQuery for serverless data warehousing). Incorrect options: B (Cloud Storage lacks transactional consistency for structured data), D (Bigtable is NoSQL, not relational), F (BigQuery is for analytical queries, not real-time transaction processing).

Exam trap

Trap: You might think Bigtable can handle relational data because it supports structured data, but it lacks joins and transactions. Similarly, BigQuery is often mistaken for an OLTP database, but it's designed for analytics on large datasets.

710
MCQeasy

A team wants to enforce governance and compliance for all ML models across the organisation. They need a centralised repository that tracks model versions, deployment history, and evaluation metrics. Which service should they use?

A.Cloud Storage
B.Vertex AI Feature Store
C.Vertex AI Experiments
D.Vertex AI Model Registry
AnswerD

Vertex AI Model Registry provides a centralised, versioned catalogue tracking each model's versions, deployment history and evaluation metrics, giving the organisation-wide governance and compliance visibility the stem requires. It integrates with Vertex AI Pipelines and endpoints, so lineage is captured automatically.

Why this answer

Vertex AI Model Registry is a centralized repository that tracks model versions, lineage, deployment history, and evaluation metrics across the organization, making it the correct choice for governance and compliance. It integrates with Vertex AI Pipelines and Model Monitoring so that every model artifact has an auditable lifecycle. This directly addresses the requirement for a single source of truth for ML models.

Exam trap

PMLE often tests the distinction between experimentation tracking (Vertex AI Experiments) and production model governance (Model Registry) — candidates pick Experiments because it also stores metrics, but it lacks deployment history and versioning for production models.

How to eliminate wrong answers

Option A is wrong because Cloud Storage is a generic object store — it can hold model artifacts but provides no versioning semantics, deployment tracking, or evaluation metric storage specific to ML governance. Option B is wrong because Vertex AI Feature Store manages feature values and serving for training/inference, not model versions or deployment history. Option C is wrong because Vertex AI Experiments tracks training runs, parameters, and metrics for experimentation, but it does not manage deployed model versions or serve as a governance repository for production models.

711
Multi-Selecthard

You are fine-tuning a large language model (LLM) from Vertex AI Model Garden using a custom dataset. You need to minimize training cost while maintaining reasonable throughput. Which THREE strategies should you combine?

Select 3 answers
A.Use spot VM instances for training
B.Use parameter-efficient fine-tuning (PEFT) such as LoRA
C.Use full fine-tuning of all model parameters
D.Use TPU v4 pods for training
E.Use mixed precision training (FP16)
AnswersA, B, E

Spot VMs are significantly cheaper than regular VMs and are suitable for fault-tolerant fine-tuning jobs.

Why this answer

Spot VM instances are significantly cheaper than on-demand instances, reducing training cost. They can be preempted, but for fine-tuning tasks that can checkpoint and resume, this trade-off is acceptable for cost savings.

Exam trap

The Google PMLE exam often tests the misconception that higher-performance hardware (like TPU pods) is always the best choice for cost optimization, when in reality, cost-minimization strategies prioritize cheaper compute and efficient training methods over raw throughput.

712
MCQmedium

You need to run batch predictions on a large dataset stored in BigQuery using a Vertex AI model. The dataset contains 10 million rows, and each prediction takes about 100ms. You want to minimize cost and execution time. What should you do?

A.Export the BigQuery data to CSV in GCS, then run a custom Dataflow pipeline to make predictions.
B.Use Vertex AI batch prediction with BigQuery as the source and sink.
C.Use Vertex AI online prediction and send all rows as separate requests.
D.Use a custom container running on Google Kubernetes Engine to perform inference.
AnswerB

Vertex AI batch prediction reads directly from BigQuery and writes results back there, avoiding data export and manual sharding. This satisfies the stem's cost and execution-time constraints by parallelising the 10 million rows across managed workers rather than issuing row-by-row online requests.

Why this answer

Vertex AI batch prediction natively supports BigQuery as both input and output, eliminating the need for data export or custom pipelines. For 10 million rows at 100ms each, batch prediction processes them in parallel across multiple machines, minimizing execution time while avoiding the per-node costs of online prediction or the overhead of managing Dataflow or GKE clusters.

Exam trap

Google Cloud exams often test the distinction between batch and online prediction, trapping candidates who overlook that batch prediction is purpose-built for large-scale, offline inference with native BigQuery integration, while online prediction is for real-time, low-latency use cases.

How to eliminate wrong answers

Option A is wrong because exporting to CSV and using Dataflow adds unnecessary complexity and cost; Vertex AI batch prediction can read directly from BigQuery, avoiding data movement and extra processing steps. Option C is wrong because online prediction is designed for low-latency, real-time requests on small payloads, and sending 10 million separate requests would be prohibitively expensive and slow due to per-request pricing and network overhead. Option D is wrong because running a custom container on GKE requires you to manage infrastructure, scaling, and fault tolerance, which is more costly and complex than using Vertex AI's managed batch prediction service.

713
Multi-Selectmedium

An MLOps engineer is setting up monitoring for a deployed model on Vertex AI Endpoints. Which TWO actions are required to enable Vertex AI Model Monitoring for feature skew and drift? (Choose two.)

Select 2 answers
A.Export ground truth labels to Cloud Storage
B.Enable request/response logging on the Vertex AI Endpoint
C.Enable Vertex AI Pipelines to run scheduled monitoring
D.Create a ModelMonitoringJob with a monitoring configuration
E.Deploy the model with an explanation spec
AnswersB, D

Model Monitoring computes skew and drift by comparing live serving traffic against the training baseline, so it needs sampled request and response payloads. Enabling request/response logging on the endpoint supplies that input, satisfying the stem's requirement for drift detection.

Why this answer

To enable model monitoring, you must enable request/response logging on the endpoint (to capture serving data) and create a monitoring job with the desired configuration.

714
MCQmedium

A company uses Vertex AI Pipelines to train and deploy models. They want to automatically generate model documentation that includes model details, intended use, and evaluation results. What should they use?

A.Vertex AI Explanations
B.Vertex AI Metadata
C.Model Cards
D.Vertex AI Model Registry with custom metadata
AnswerC

Model Cards generate structured documentation covering model details, intended use and evaluation results, directly satisfying the documentation requirement. They attach to registered models in Vertex AI Model Registry, pulling evaluation metrics automatically rather than requiring manual authoring.

Why this answer

Model Cards are a standardized format for model documentation, and Vertex AI supports automated generation of model cards.

715
MCQhard

A financial services firm serves a fraud-detection model on a Vertex AI endpoint that consumes features from a Vertex AI Feature Store online store. During a load test, prediction latency is acceptable, but the firm discovers that the model's feature values in production drift from the values used at training time because the training pipeline read from a BigQuery table with different transformation logic. The team wants the serving path to use the same feature definitions as training so online and offline values match. Which approach should they take?

A.Log all online feature values and retrain the model weekly on the logged production data.
B.Increase the online store's node count and shorten the feature value TTL so fresher values are served.
C.Route serving requests through the offline store and cache results in Memorystore for low latency.
D.Define the features once as Feature Store feature views with a shared transformation and serve the model from the online store while the training pipeline reads the same definitions from the offline store.
AnswerD

Feature Store provides a single definition for each feature, materialized to the online store for low-latency serving and to the offline store for training. When both paths derive from the same feature view and transformation, online and offline values are computed identically, which is the definition of training-serving skew prevention. This directly removes the divergent BigQuery logic that caused the drift.

Why this answer

Training-serving skew from divergent transformation logic is solved by unifying feature definitions, not by tuning storage or adding caching. Vertex AI Feature Store lets a feature view define a transformation once, then materialize the result to the online store for low-latency serving and to the offline store for training. Because both paths derive from the same definition, the values the model sees at inference match the values it was trained on, eliminating the drift at its source.

Exam trap

The trap here is treating a semantic mismatch between two transformation implementations as a latency or freshness problem, and reaching for storage scaling or caching instead of unifying the feature definition.

716
MCQmedium

An ML engineer is scaling a prototype to production using Vertex AI Pipelines. The pipeline includes data validation, preprocessing, training, and deployment steps. They want to ensure that the pipeline can be reproduced and audited. What is the best practice?

A.Define the pipeline using Kubeflow Pipelines SDK and run it on Vertex AI Pipelines.
B.Use a Docker container with fixed tags and manually record runs.
C.Store all data and models in a single Cloud Storage bucket with no versioning.
D.Pin all library versions in a requirements.txt file.
AnswerA

Defining the pipeline with the Kubeflow Pipelines SDK gives a versioned, declarative specification that Vertex AI Pipelines executes and records, so each run is reproducible and auditable. Ad hoc scripts or manual steps would not provide this traceability.

Why this answer

Defining the pipeline with the Kubeflow Pipelines (KFP) SDK and running it on Vertex AI Pipelines produces a versioned, declarative pipeline specification (a compiled YAML/JSON IR) that captures each step, its container image, inputs, outputs, and parameters. Vertex AI Pipelines stores this as a reproducible pipeline run with lineage tracking, so any execution can be audited and re-run deterministically. This is the canonical Google-recommended approach for reproducible, auditable ML workflows on Vertex AI.

Exam trap

The trap here is confusing partial reproducibility measures (pinning requirements.txt, using fixed Docker tags) with full pipeline reproducibility, which requires a versioned, declarative pipeline definition plus automatic artifact lineage.

How to eliminate wrong answers

Option B is wrong because fixed Docker tags are mutable and manually recorded runs are error-prone and provide no automatic lineage or reproducibility guarantees. Option C is wrong because storing data and models in a single bucket without versioning destroys the ability to reproduce a specific training run or recover prior artifacts. Option D is wrong because pinning library versions in requirements.txt is only one small piece of reproducibility and does not capture pipeline structure, data versions, or execution lineage.

717
MCQeasy

A data scientist wants to define a lightweight Python function component in Vertex AI Pipelines using Kubeflow Pipelines SDK v2. Which decorator should be applied to the function to make it a pipeline component?

A.@dsl.pipeline
B.@kfp.v2.components.func_to_component
C.@dsl.component
D.@kfp.dsl.component
AnswerC

The @dsl.component decorator converts a plain Python function into a lightweight KFP v2 component, with the function's signature defining its inputs and outputs. This is the specific mechanism the stem requests for authoring a Python function component in Kubeflow Pipelines SDK v2.

Why this answer

In Kubeflow Pipelines SDK v2, the @dsl.component decorator converts a lightweight Python function into a pipeline component. This is the standard v2 approach for defining function-based components. @dsl.pipeline is used to define the pipeline itself, not individual components.

Exam trap

PMLE often tests the distinction between @dsl.component (defines a component) and @dsl.pipeline (defines the pipeline), and includes legacy v1 decorators like func_to_component to confuse candidates about SDK v2 syntax.

How to eliminate wrong answers

Option A is wrong because @dsl.pipeline decorates the pipeline function that orchestrates components, not the component function itself. Option B is wrong because @kfp.v2.components.func_to_component is the older v1-style API for converting functions to components; in SDK v2 the canonical decorator is @dsl.component. Option D is wrong because @kfp.dsl.component is not the correct v2 decorator syntax; the v2 SDK uses @dsl.component from the kfp.dsl module.

718
MCQmedium

A marketing team needs to build a model that predicts whether a customer will respond to a promotional email. They have a BigQuery table with 2 million rows and 30 features, and they want to avoid writing any Python code. They require an explainable model and the ability to generate predictions directly in SQL. Which approach should they use?

A.Use BigQuery ML to create a k-means clustering model to segment customers, then manually assign response probabilities based on cluster averages.
B.Create a BigQuery ML logistic regression model using CREATE MODEL with model_type='LOGISTIC_REG', then use ML.PREDICT for scoring.
C.Export the data to Cloud Storage and train a custom TensorFlow model using Vertex AI Training with a pre-built container.
D.Use AutoML Tables (now Vertex AI Tabular) to train a model, then deploy it to an endpoint and call it from BigQuery using a remote function.
AnswerB

BigQuery ML supports logistic regression for binary classification directly via SQL. The CREATE MODEL statement with model_type='LOGISTIC_REG' trains the model without Python, and ML.PREDICT generates predictions in SQL. Logistic regression is inherently explainable because coefficients indicate feature importance and direction, satisfying the explainability requirement.

Why this answer

BigQuery ML enables training and prediction using SQL, which perfectly matches the team's need to avoid Python. Logistic regression is a standard binary classification model that provides interpretable coefficients, satisfying explainability. Creating the model with CREATE MODEL and scoring with ML.PREDICT keeps the entire workflow within BigQuery, leveraging its scalability for 2 million rows.

Other options either require coding, use inappropriate algorithms, or involve external services that complicate the low-code requirement.

Exam trap

The trap here is assuming that low-code solutions like AutoML are always the best fit, overlooking that BigQuery ML can handle the entire workflow in SQL without any external tools.

719
Multi-Selecthard

A company is experiencing high prediction costs on Vertex AI Endpoints. They want to monitor and optimize costs. Which THREE actions should they take? (Choose 3)

Select 3 answers
A.Use Cloud Billing reports to track Vertex AI endpoint costs per hour and per request
B.Use Vertex AI Explainability on every prediction
C.Reduce the number of replicas or use autoscaling to minimize idle resources
D.Set up budget alerts in Google Cloud Billing to notify when costs exceed a threshold
E.Enable Vertex AI Model Monitoring to track prediction latency
AnswersA, C, D

Cloud Billing provides cost breakdowns by service and resource.

Why this answer

Option A is correct because Cloud Billing reports let you break down Vertex AI endpoint charges by labels, SKU, and time granularity, giving visibility into per-hour and per-request prediction costs so optimization decisions are data-driven. Option C is correct because prediction cost on Vertex AI Endpoints is driven largely by the number of deployed replicas and machine hours; reducing replicas or configuring autoscaling (e.g., minReplicaCount/maxReplicaCount with a target utilization metric) eliminates idle capacity and directly lowers spend. Option D is correct because budget alerts in Cloud Billing proactively notify stakeholders when actual or forecasted costs exceed a defined threshold, enabling timely corrective action before prediction costs escalate.

Option B does not belong because Vertex AI Explainability adds feature attribution to predictions, which increases compute and cost rather than optimizing it. Option E does not belong because Model Monitoring tracks data drift, skew, and prediction quality metrics, not cost, and it does not reduce prediction expenses.

Exam trap

PMLE often tests the distinction between observability features (Explainability, Model Monitoring) and cost-management features (Billing reports, autoscaling, budget alerts) — candidates incorrectly assume any 'monitoring' tool helps with cost.

720
MCQmedium

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?

A.The model architecture is too simple to benefit from distribution
B.The workers are not using the same version of TensorFlow
C.Communication overhead due to gradient synchronization
D.The GPUs are not configured correctly
AnswerC

MultiWorkerMirroredStrategy performs all-reduce gradient synchronisation across workers each step, so inter-worker communication overhead grows with worker count and prevents linear scaling. With 4 workers and 16 GPUs, network latency and bandwidth for exchanging gradients, not compute, become the bottleneck limiting throughput gains.

Why this answer

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.

Exam trap

The trap here is that candidates often assume more workers always means linear speedup, ignoring the fixed overhead of gradient synchronization that becomes the dominant factor in distributed training.

How to eliminate wrong answers

Option A is wrong because even a simple model can suffer from communication overhead if the compute-to-communication ratio is low; the issue is not model simplicity but the cost of synchronizing gradients across workers. Option B is wrong because TensorFlow enforces version consistency across workers in a distributed job; mismatched versions would cause a job failure, not sublinear scaling. Option D is wrong because GPU misconfiguration (e.g., incorrect driver or CUDA version) would typically cause errors or zero utilization, not gradual scaling degradation; the observed symptom of sublinear scaling points to communication, not hardware misconfiguration.

721
MCQhard

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?

A.MultiWorkerMirroredStrategy
B.Parameter server strategy
C.MirroredStrategy (data parallelism)
D.Pipeline parallelism (model parallelism)
AnswerD

Pipeline parallelism partitions the model's layers across GPUs, so each device holds only a subset of parameters and activations. This directly addresses the constraint that the model exceeds single-GPU memory. Data parallelism would replicate the full model on every GPU, which remains impossible.

Why this answer

Pipeline parallelism (model parallelism) is the correct choice because it splits the model's layers across multiple GPUs, allowing a model too large for a single GPU's memory to be trained. Each GPU holds a subset of layers and processes micro-batches in a pipelined fashion, enabling training of models that exceed single-device memory. This directly addresses the memory constraint by distributing the model parameters, not just the data.

Exam trap

The trap here is confusing data parallelism (which replicates the model) with model parallelism (which splits the model), and overlooking that the problem explicitly states the model does not fit in a single GPU's memory, making any data-parallel strategy incorrect.

How to eliminate wrong answers

Option A is wrong because MultiWorkerMirroredStrategy is designed for multi-worker (multi-machine) synchronous data parallelism, not for splitting a single model across GPUs on one machine. Option B is wrong because parameter server strategy is an asynchronous data-parallel approach where workers compute gradients and a parameter server updates weights; it does not split model layers across devices and is typically used for large-scale distributed training across many machines, not for fitting a single large model on one machine. Option C is wrong because MirroredStrategy (data parallelism) replicates the entire model on each GPU, which fails when the model does not fit in a single GPU's memory.

722
MCQmedium

A company uses Vertex AI Pipelines to train models on a daily schedule. The pipeline includes a component that runs a BigQuery query to extract features. The team wants to ensure that if the BigQuery component fails due to transient network errors, the pipeline automatically retries it. How can they configure retries in Vertex AI Pipelines?

A.Deploy the component as a Cloud Function and configure Cloud Functions retry.
B.Wrap the component in a `dsl.If` conditional that checks for failure and re-submits the component.
C.Use Cloud Composer with a task retry policy in Airflow.
D.Set the `retry` parameter of the component to a positive integer, for example `retry=3`.
AnswerD

The retry parameter on a task or component specifies how many times Vertex AI Pipelines re-executes it after failure, so retry=3 automatically reruns the BigQuery component on transient network errors. This satisfies the stem's automatic-retry requirement.

Why this answer

Vertex AI Pipelines natively supports a `retry` parameter on pipeline components. Setting `retry=3` instructs the pipeline to automatically retry the component up to three times if it fails due to transient errors, such as network timeouts. This is the simplest and most direct way to handle retries within the Vertex AI Pipelines orchestration framework.

Exam trap

The trap here is that candidates may confuse Vertex AI Pipelines' native `retry` parameter with external retry mechanisms (Cloud Functions, Airflow) or misuse pipeline control flow constructs like `dsl.If` for retry logic, when the correct approach is a simple parameter on the component definition.

How to eliminate wrong answers

Option A is wrong because deploying the component as a Cloud Function and configuring Cloud Functions retry would move the execution outside of Vertex AI Pipelines, breaking the pipeline's orchestration and monitoring. Option B is wrong because `dsl.If` conditionals are used for conditional execution of components, not for retrying a failed component; they cannot re-submit a component that has already failed. Option C is wrong because Cloud Composer with Airflow is a separate orchestration service that would require migrating the entire pipeline out of Vertex AI Pipelines, adding unnecessary complexity and cost.

723
MCQeasy

Which API is recommended for high-throughput, low-latency online prediction requests to Vertex AI endpoints?

A.Cloud Functions
B.REST API
C.Cloud Pub/Sub
D.gRPC API
AnswerD

gRPC API uses HTTP/2 multiplexing and binary Protocol Buffers, cutting serialisation overhead and connection latency compared with REST's JSON over HTTP/1.1. This directly satisfies the stem's high-throughput, low-latency constraint for online prediction requests to Vertex AI endpoints.

Why this answer

gRPC API is recommended for high-throughput, low-latency online prediction requests to Vertex AI endpoints because it uses HTTP/2 for multiplexed streaming, binary serialization (Protocol Buffers), and supports bidirectional streaming, which reduces latency and improves throughput compared to REST. Vertex AI's prediction service natively supports gRPC for real-time inference, making it the optimal choice for latency-sensitive applications.

Exam trap

Google often tests the misconception that REST API is the default or only way to interact with cloud services, but the trap here is that for high-throughput, low-latency online predictions, gRPC is explicitly recommended over REST due to its performance advantages with Protocol Buffers and HTTP/2.

How to eliminate wrong answers

Option A is wrong because Cloud Functions is a serverless compute service for event-driven code, not an API for making prediction requests; it can invoke Vertex AI endpoints via REST or gRPC but is not itself an API protocol. Option B is wrong because REST API uses HTTP/1.1 with JSON serialization, which introduces higher latency and larger payload sizes compared to gRPC's binary Protocol Buffers, making it suboptimal for high-throughput, low-latency scenarios. Option C is wrong because Cloud Pub/Sub is a message queue for asynchronous, decoupled messaging, not designed for synchronous, low-latency online predictions; it adds queuing delay and is intended for batch or event-driven workflows.

724
Multi-Selectmedium

A model serving team is experiencing high latency in production. Which TWO actions should they take to diagnose the root cause? (Choose 2.)

Select 2 answers
A.Convert the model to a different framework that is faster.
B.Enable Cloud Trace to analyze request latency across services.
C.Check the endpoint's autoscaling metrics and cold start frequency.
D.Increase the number of replicas to reduce load per replica.
E.Set the logging verbosity to DEBUG in the container.
AnswersB, C

Cloud Trace captures distributed traces across your serving path, breaking end-to-end request latency into per-service and per-span timings. This directly satisfies the stem's need to diagnose where latency originates, revealing whether delay sits in preprocessing, model inference, or downstream calls rather than merely confirming that latency exists.

Why this answer

The correct actions to diagnose root cause of high latency are enabling Cloud Trace (B) and checking autoscaling metrics and cold start frequency (C). Cloud Trace provides detailed latency breakdown across services, helping identify bottlenecks. Checking autoscaling and cold start metrics reveals if latency is due to scaling delays or initialization overhead.

Option A (converting framework) is not a diagnostic step and may introduce risk. Option D (increasing replicas) may temporarily reduce load but does not diagnose the cause. Option E (DEBUG logging) adds overhead without providing latency analysis.

725
MCQmedium

You are deploying a model to a Vertex AI Endpoint that will serve predictions to a global user base. You want to minimize latency for users in different regions while ensuring high availability. What should you do?

A.Deploy the model to multiple endpoints in the same region and use a global load balancer.
B.Deploy the model to a single endpoint in one region and use a global load balancer to route traffic.
C.Deploy the model to a single endpoint with a larger machine type to handle global traffic.
D.Deploy the model to multiple endpoints in different regions and use a global load balancer with latency-based routing.
AnswerD

Deploying the model to multiple regional endpoints brings the model closer to users, reducing network latency. A global load balancer with latency-based routing directs each user to the closest healthy endpoint, minimizing latency and providing high availability by failing over if a region becomes unavailable.

Why this answer

To minimize latency for a global user base, the model should be deployed in multiple regions so that users can be served from a nearby location. A global load balancer with latency-based routing ensures that each user is directed to the closest healthy endpoint, reducing latency and providing failover for high availability. Single-region deployments, even with larger machines or multiple endpoints in one region, cannot overcome geographic latency.

Exam trap

The trap here is focusing on capacity or redundancy within a single region instead of geographic distribution to reduce latency for a global user base.

726
Multi-Selecthard

A pipeline includes a component that produces a model artifact. The team wants to automatically detect skew between the training data distribution and the serving data distribution. Which three best practices should they implement? (Choose three.)

Select 3 answers
A.Compare statistics using a dedicated component and alert on threshold exceedance
B.Use in-memory data passing for efficiency
C.Compute serving data statistics using a component
D.Disable caching to ensure fresh statistics
E.Pass training data statistics as a Dataset artifact
AnswersA, C, E

A dedicated comparison component computes the statistical distance between training and serving distributions and raises alerts when thresholds are exceeded, satisfying the automatic detection requirement. Isolating this logic keeps skew monitoring reproducible and lets thresholds be tuned without retraining the model.

Why this answer

Option A is correct because skew detection requires a dedicated comparison component that evaluates training versus serving statistics and raises an alert when a configured threshold (e.g., a divergence metric like KL divergence or PSI) is exceeded. Option C is correct because you must compute statistics on the serving data itself, typically via a component that ingests the live inference data and emits a statistics artifact for comparison. Option E is correct because the training data statistics should be persisted and passed as a Dataset artifact so the comparison component can consume them reproducibly across pipeline runs.

Option B is wrong because in-memory data passing does not persist artifacts and is unsuitable for cross-component, cross-run statistical comparison. Option D is wrong because disabling caching does not improve statistical correctness and only adds unnecessary recomputation cost.

727
MCQeasy

A company wants to log all prediction requests and responses from a Vertex AI Endpoint to BigQuery for auditing and debugging. How can they achieve this?

A.Export endpoint logs from Cloud Logging to Cloud Storage and then load into BigQuery manually.
B.Use a Cloud Function to intercept predictions and write to BigQuery.
C.Vertex AI endpoints do not support request/response logging.
D.Enable request/response logging on the endpoint and create a BigQuery sink for the log.
AnswerD

Enabling request/response logging on the Vertex AI Endpoint captures the full prediction payloads, satisfying the audit requirement for both inputs and outputs. Routing those logs to BigQuery via a sink then makes them queryable for debugging. Sampling settings must be set to capture all traffic, since default sampling is partial.

Why this answer

Vertex AI endpoints can be configured to enable request/response logging. The logs can be sent to a BigQuery table via a log sink.

728
MCQmedium

You have a prototype model trained on a small sample of data. You now want to train on the full dataset using Vertex AI, but the dataset is stored in BigQuery and is several terabytes. You need to minimize data movement and avoid exporting the full dataset to Cloud Storage. What should you do?

A.Export the BigQuery table to Cloud Storage as CSV and pass the Cloud Storage path to the training job.
B.Use the BigQuery reader in the training application to read data directly from BigQuery during training.
C.Create a Dataproc cluster to convert the BigQuery table to Parquet in Cloud Storage, then train from that path.
D.Load the BigQuery table into a Vertex AI Feature Store and train from the feature store online serving endpoint.
AnswerB

Vertex AI custom training supports reading data directly from BigQuery using client libraries or the BigQuery Storage API. This avoids exporting the dataset and keeps data in place, which minimizes movement and storage duplication. The training container can stream or batch records from BigQuery, and you can control the query to select only needed columns or rows, reducing I/O further.

Why this answer

When training data lives in BigQuery and the goal is to avoid moving it, the training application should read from BigQuery directly using the available client libraries or Storage API. This keeps the data in place and avoids exporting terabytes to Cloud Storage. Exporting to CSV or Parquet, or routing through Feature Store, adds unnecessary copies or is not designed for bulk training reads.

Exam trap

The trap here is assuming that training data must always be staged in Cloud Storage, when Vertex AI training can read directly from BigQuery.

729
MCQmedium

A model deployed on Vertex AI Prediction is returning high latency for real-time requests. The model is a small TensorFlow model. Which troubleshooting step should the team take first?

A.Retrain the model with a larger batch size
B.Check if the machine type is too small and enable autoscaling
C.Use a custom container with optimized runtime
D.Enable Cloud Armor to reduce traffic
AnswerB

A small TensorFlow model should not be inherently slow, so insufficient machine resources or lack of scaling is the likely bottleneck. Checking the machine type and enabling autoscaling addresses CPU or memory saturation before deeper model-level investigation.

Why this answer

High latency for real-time predictions from a small TensorFlow model often indicates that the serving infrastructure is under-provisioned. Checking the machine type and enabling autoscaling directly addresses whether the instance is too small to handle the request volume, which is the most common first step in diagnosing latency issues on Vertex AI Prediction.

Exam trap

Google Cloud often tests the principle of 'start with the simplest infrastructure fix before optimizing the model or container,' so candidates mistakenly jump to retraining or custom containers without first checking if the instance type and scaling settings are appropriate.

How to eliminate wrong answers

Option A is wrong because retraining with a larger batch size affects training throughput, not inference latency for real-time requests; inference batch size is set at serving time, not during training. Option C is wrong because using a custom container with an optimized runtime is a more advanced optimization step that should be considered only after verifying that the base infrastructure (machine type and scaling) is adequate. Option D is wrong because Cloud Armor is a security service for DDoS protection and traffic filtering, not a tool for reducing latency caused by insufficient compute resources.

730
MCQhard

A data science team has trained a TensorFlow model on-premises using a large dataset. When they try to deploy the model to Vertex AI for online predictions, the deployed model fails to start with a ‘MemoryError’. The model artifact is 2 GB, and the machine type is n1-standard-4 (15 GB RAM). What is the most likely cause?

A.The model is stored in a regional bucket and the Vertex AI endpoint is in a different region.
B.The machine type does not support TensorFlow models larger than 1 GB.
C.The model is too large for the machine's memory, causing an out-of-memory (OOM) error during loading.
D.The model file is corrupted or missing dependencies, causing a crash.
AnswerC

Vertex AI loads the entire 2 GB artifact into the container's RAM before serving. The n1-standard-4 provides 15 GB, but TensorFlow runtime overhead plus deserialisation can exhaust it, so the process is killed with MemoryError rather than a configuration fault.

Why this answer

The model artifact is 2 GB, and loading it into memory on an n1-standard-4 machine (15 GB RAM) can still cause a MemoryError. TensorFlow models often require additional memory for graph construction, intermediate tensors, and framework overhead, which can easily exceed the available RAM, especially when the model is loaded entirely into memory before serving.

Exam trap

Google Cloud often tests the misconception that model file size must be less than total machine RAM to avoid OOM errors, but the trap here is that TensorFlow's memory footprint during loading and serving is significantly larger than the artifact size due to framework overhead and graph construction.

How to eliminate wrong answers

Option A is wrong because a regional bucket mismatch would cause a permission or access error, not a MemoryError; Vertex AI can access models from any regional bucket as long as the service account has proper permissions. Option B is wrong because there is no inherent machine type limitation that restricts TensorFlow models to 1 GB; the n1-standard-4 can handle larger models if sufficient memory is available. Option D is wrong because a corrupted file or missing dependencies would typically result in an ImportError or a crash with a different error message, not a MemoryError.

731
MCQmedium

An ML engineer notices that predictions are taking longer than expected under moderate traffic. Reviewing the endpoint configuration, what is the most likely cause of the high latency?

A.Container logging is disabled, slowing down request processing.
B.The accelerator count is 0, meaning no GPU is used.
C.The machine type n1-standard-4 is underpowered for the model's compute needs.
D.Automatic scaling is set with a maxReplicaCount of 10, which creates overhead.
AnswerB

An accelerator count of 0 means the deployment runs on CPU only, so inference executes without GPU parallelism and latency rises under moderate load. This directly satisfies the stem's observed slowdown, since GPU-backed endpoints process matrix operations far faster.

Why this answer

When the accelerator count is set to 0, the endpoint runs inference on the CPU only, which is significantly slower than GPU-accelerated inference for deep learning models. This is the most direct cause of high latency under moderate traffic, as the model's compute demands exceed CPU throughput.

Exam trap

Google Cloud often tests the misconception that CPU machine type is the primary cause of latency, when in fact the accelerator count being zero is the more direct and common misconfiguration for deep learning models.

How to eliminate wrong answers

Option A is wrong because disabling container logging reduces I/O overhead and actually speeds up request processing, not slows it down. Option C is wrong because n1-standard-4 (4 vCPUs, 15 GB RAM) is a standard compute-optimized machine type that is generally sufficient for moderate traffic; the primary bottleneck is the lack of GPU acceleration, not CPU underpowering. Option D is wrong because a maxReplicaCount of 10 does not create overhead; automatic scaling with a higher maxReplicaCount allows more instances to handle load, reducing latency under traffic.

732
MCQhard

An ML pipeline runs on Vertex AI and includes a component that uses a third-party library not available in the default Python environment. The team wants to avoid building a custom container image. Which approach should they use?

A.Install the library using pip in the pipeline definition
B.Use a container component with a pre-built image
C.Use the packages_to_install parameter in @dsl.component
D.Add the library to the Vertex AI custom training image
AnswerC

Using `packages_to_install` in `@dsl.component` lets the Vertex AI Pipelines compiler install the third-party library into the component's runtime environment at execution, satisfying the constraint of avoiding a custom container image. The dependency is resolved by pip during task startup rather than being baked into the image.

Why this answer

The `packages_to_install` parameter in the `@dsl.component` decorator allows you to specify a list of third-party Python packages (e.g., via pip) that will be installed at runtime in the component's execution environment, without needing to build a custom container image. This is the recommended approach in Vertex AI Pipelines when you need to use a library not present in the default Python environment, as it avoids the overhead of custom container creation while ensuring the dependency is available for that specific component.

Exam trap

The trap here is that candidates often confuse the `packages_to_install` parameter in Vertex AI's `@dsl.component` with a generic pip install in the pipeline definition, or they assume a pre-built container image avoids custom image building—but in Vertex AI, any container image that includes the library must be custom-built or selected from a registry, which still involves image management overhead. The `packages_to_install` parameter is the native Vertex AI way to install packages without custom containers.

How to eliminate wrong answers

Option A is wrong because `pip install` in the pipeline definition (e.g., in a Python function or YAML) is not a supported mechanism in Vertex AI Pipelines; the pipeline definition itself does not execute shell commands, and dependencies must be declared via the component decorator. Option B is wrong because using a container component with a pre-built image still requires building a custom container image (even if it's pre-built, you must create or select one that includes the library), which contradicts the requirement to avoid building a custom container image. Option D is wrong because adding the library to the Vertex AI custom training image involves creating a custom container image for training, which is a separate process from pipeline components and also requires building a custom image, violating the constraint.

733
MCQeasy

A company needs to extract text from scanned invoices and parse key fields like invoice number and total amount. Which Document AI processor should they use?

A.OCR Processor
B.Contract Parser
C.Form Parser
D.Invoice Parser
AnswerD

Invoice Parser combines OCR with pre-trained extraction of invoice-specific fields such as invoice number and total amount, satisfying the requirement to parse key fields from scanned invoices. Unlike generic OCR, which returns raw text only, it maps recognised content directly to structured invoice schema, removing custom model training.

Why this answer

The Invoice Parser is a specialized Document AI processor pre-trained to extract structured data from invoices, including fields like invoice number, total amount, due date, and line items. It goes beyond generic OCR by understanding the invoice layout and returning key-value pairs. OCR Processor only extracts raw text without parsing fields, while Form Parser and Contract Parser are for general forms and contracts, respectively.

Exam trap

The trap here is confusing generic OCR with specialized parsing; candidates might think OCR is sufficient for extracting fields, but it only provides raw text without structure.

How to eliminate wrong answers

Option A is wrong because the OCR Processor only performs optical character recognition to extract text, but does not parse specific fields like invoice number or total amount. Option B is wrong because the Contract Parser is designed for legal contracts, not invoices, and would not reliably extract invoice-specific fields. Option C is wrong because the Form Parser is a generic form processor that can extract key-value pairs but is not pre-trained specifically for invoices, so it may require custom training and lacks invoice-specific fields.

734
MCQmedium

An organization wants to deploy a TensorFlow model on edge devices such as smartphones and IoT devices for offline inference. Which format should they export the model to?

A.ONNX format
B.TensorFlow Lite (TFLite)
C.SavedModel format
D.HDF5 format
AnswerB

TensorFlow Lite converts models to a compact FlatBuffer format with quantisation, cutting size and latency for constrained hardware. It provides the lightweight runtime that executes inference entirely on-device, satisfying the offline requirement for smartphones and IoT devices without server connectivity.

Why this answer

TensorFlow Lite (TFLite) is Google's lightweight runtime and model format specifically designed for on-device inference on mobile and embedded/IoT hardware. It produces a compact .tflite flatbuffer optimized for low latency, small binary size, and minimal memory, and supports hardware acceleration via delegates (GPU, NNAPI, Edge TPU). Exporting to TFLite is the standard path for offline inference on smartphones and IoT devices.

Exam trap

PMLE often tests the confusion between SavedModel (cloud/TF Serving) and TFLite (edge/mobile), so candidates who equate 'TensorFlow model export' with SavedModel pick the wrong format for constrained devices.

How to eliminate wrong answers

Option A is wrong because ONNX is an open interchange format primarily used for cross-framework portability (e.g., PyTorch to TensorRT), not the native optimized format for TensorFlow edge deployment. Option C is wrong because SavedModel is TensorFlow's full-fidelity serving format for TF Serving and cloud endpoints — it is too heavy for constrained edge devices. Option D is wrong because HDF5 (.h5) is the legacy Keras weight/architecture serialization format used for training checkpoints, not for optimized edge inference.

735
MCQhard

A company has deployed a machine learning model that uses a large input tensor. They notice that the prediction latency varies significantly between requests of the same size. Cloud Monitoring shows that the serving endpoint's CPU utilization is consistently below 50%, but memory utilization fluctuates between 70% and 95%. What is the most likely cause?

A.The model is performing garbage collection cycles
B.The model is using excessive memory due to a memory leak
C.The prediction latency is being affected by CPU throttling
D.The model is hitting a cold start due to autoscaling
AnswerA

With CPU below 50% but memory swinging between 70% and 95%, the variability stems from memory reclamation rather than compute saturation. Garbage collection cycles pause request handling while reclaiming the large input tensor's allocations, producing latency spikes that correlate with memory pressure, not CPU load.

Why this answer

The described symptoms—low CPU utilization (below 50%) and high, fluctuating memory utilization (70%–95%) with variable latency—are classic indicators of garbage collection (GC) pauses in a managed runtime like Python or Java. When the model processes large input tensors, it allocates significant memory; as memory pressure builds, the garbage collector runs more frequently, causing stop-the-world pauses that increase latency unpredictably, even though CPU is not fully utilized.

Exam trap

Google Cloud often tests the misconception that high memory utilization always indicates a memory leak, but the key differentiator is the pattern of fluctuation versus monotonic increase, and the fact that GC pauses cause latency spikes without high CPU usage.

How to eliminate wrong answers

Option B is wrong because a memory leak would cause memory utilization to steadily increase over time (monotonically) rather than fluctuate between 70% and 95%, and it would eventually lead to an out-of-memory crash, not just variable latency. Option C is wrong because CPU throttling (e.g., due to thermal limits or cloud provider CPU credits exhaustion) would manifest as sustained high CPU utilization or a hard cap on CPU speed, not consistently below 50% utilization. Option D is wrong because cold starts due to autoscaling occur when new instances are spun up to handle increased load, which would show a correlation with request volume spikes and initial high latency on the first request, not persistent latency variation across all requests of the same size.

736
MCQeasy

A data science team wants to share engineered features across multiple projects while ensuring low-latency serving for online predictions. Which Google Cloud service should they use to store and serve these features?

A.Vertex AI Model Registry
B.Cloud Storage
C.BigQuery
D.Vertex AI Feature Store
AnswerD

Vertex AI Feature Store provides a centralised repository for engineered features with low-latency online serving, letting multiple projects reuse the same feature definitions. This satisfies both the sharing requirement and the online prediction latency constraint.

Why this answer

Vertex AI Feature Store is purpose-built to store, share, and serve machine learning features with low-latency online serving and consistent offline serving for training. It lets a data science team centralize engineered features so multiple projects reuse them, while providing an online serving endpoint that returns feature values in milliseconds for real-time predictions.

Exam trap

PMLE often tests the distinction between storing models (Model Registry) and storing features (Feature Store) — candidates conflate the two because both are 'Vertex AI' artifacts.

How to eliminate wrong answers

Option A is wrong because Vertex AI Model Registry stores and versions trained models, not feature data, and provides no low-latency feature-serving endpoint. Option B is wrong because Cloud Storage is object storage with high-latency access patterns, unsuitable for millisecond online feature retrieval and lacking feature-versioning or point-in-time correctness. Option C is wrong because BigQuery is an analytical warehouse optimized for large-scale SQL scans, not sub-millisecond per-entity online lookups, and it lacks native feature-serving semantics.

737
MCQmedium

You need to run a distributed training job on Vertex AI using TensorFlow with MirroredStrategy on a single machine with 4 GPUs. Which training configuration should you use?

A.Use MirroredStrategy with a single workerPoolSpec containing a machine_type with 4 GPUs
B.Use MultiWorkerMirroredStrategy with multiple workerPools
C.Use MirroredStrategy with two workerPoolSpecs, each with 2 GPUs
D.Use ParameterServerStrategy with a chief and a parameter server
AnswerA

MirroredStrategy replicates variables across all four GPUs on one host and synchronises gradients via NVIDIA NCCL all-reduce, so a single workerPoolSpec with a four-GPU machine_type satisfies the single-machine constraint. Adding extra replicas would introduce multi-worker distribution, which MirroredStrategy does not handle.

Why this answer

MirroredStrategy is TensorFlow's single-machine, multi-GPU strategy that replicates the model across all GPUs on one host using all-reduce for gradient synchronization. On Vertex AI, this maps to a single workerPoolSpec whose machine type has 4 GPUs attached. No additional workers are needed because MirroredStrategy operates within one machine.

Exam trap

PMLE often tests the boundary between single-machine and multi-machine strategies — candidates who see '4 GPUs' and assume 'distributed across machines' incorrectly choose MultiWorkerMirroredStrategy instead of MirroredStrategy on one worker pool.

How to eliminate wrong answers

Option B is wrong because MultiWorkerMirroredStrategy is for multi-machine (multi-node) training and requires multiple worker pools — it is unnecessary and incorrect for a single machine with 4 GPUs. Option C is wrong because MirroredStrategy does not span multiple worker pools; splitting into two workerPoolSpecs would imply two machines, which contradicts the single-machine requirement and would require MultiWorkerMirroredStrategy instead. Option D is wrong because ParameterServerStrategy is a different distributed paradigm (parameter servers + workers) used for asynchronous or large-scale training, not for single-machine mirrored training.

738
MCQhard

An ML engineer is preparing to train a large recommendation model on Vertex AI. The model uses a custom training loop in PyTorch and requires a multi-node cluster with 8 A100 GPUs per node. The engineer wants to minimize training time and ensure the job can recover from a node failure without restarting from scratch. Which combination of Vertex AI features should the engineer use?

A.Use a custom training job with a worker pool of 8 A100 GPUs per replica and multiple replicas, enable distributed training with the PyTorch distributed launcher, and write checkpoints to Cloud Storage periodically.
B.Use Vertex AI Pipelines to orchestrate the training as a series of steps, with each step training on a subset of data, and use pipeline caching to avoid retraining on failure.
C.Use a Vertex AI custom training job with a single replica of 8 A100 GPUs and enable automatic machine restart, then rely on the default checkpointing behavior of the PyTorch training loop.
D.Use a Vertex AI hyperparameter tuning job with a single replica of 8 A100 GPUs, relying on early stopping to reduce training time.
AnswerA

A custom training job with multiple replicas and 8 A100 GPUs each provides the required multi-node cluster. Vertex AI handles the distributed environment variables and network setup, and the PyTorch distributed launcher coordinates ranks across nodes. Periodic checkpoints to Cloud Storage allow the job to resume from the latest checkpoint after a node failure, satisfying both performance and recovery requirements.

Why this answer

The requirement is a multi-node A100 cluster with fault tolerance. A Vertex AI custom training job with multiple replicas, each with 8 A100 GPUs, supplies the cluster, and the PyTorch distributed launcher coordinates training across nodes. Writing checkpoints to Cloud Storage at intervals lets the job resume after a node failure without losing all progress, which is the standard pattern for large distributed training on Vertex AI.

Exam trap

The trap here is confusing orchestration or tuning features with the distributed training runtime, when only a properly configured custom training job with multiple replicas provides the required multi-node GPU cluster.

739
Multi-Selectmedium

You are scaling a prototype ML model to production on Vertex AI. The model is trained with a custom training job and you want to ensure reproducibility and traceability of each training run. Which two practices should you implement? (Choose two.)

Select 2 answers
A.Store the trained model artifacts in a Cloud Storage bucket with a unique timestamped folder for each run.
B.Store the training code in a Git repository and pass the commit hash as a hyperparameter or label to the Vertex AI training job.
C.Use the same machine type and accelerator for every training run to ensure identical hardware.
D.Enable Vertex AI Model Monitoring on the endpoint to detect training-serving skew.
E.Use Vertex AI Experiments to log parameters, metrics, and artifacts for each training run.
AnswersB, E

Recording the Git commit hash with the training job creates a direct link between the code version and the resulting model. This enables reproducibility because you can check out the exact code that produced a model, and it provides traceability for audits. Vertex AI training jobs support labels and hyperparameters, so you can include the commit hash as metadata without affecting the training logic.

Why this answer

To ensure reproducibility and traceability, you need to record the exact code version and the training parameters and metrics. Storing the Git commit hash with the training job links the model to the code, while Vertex AI Experiments logs parameters, metrics, and artifacts for each run. Together, these practices allow you to reproduce any model and trace its lineage.

Model monitoring, hardware consistency, and timestamped folders do not provide the necessary metadata linkage.

Exam trap

The trap here is focusing on operational practices like hardware consistency or artifact organization, which do not capture the code and parameter metadata required for true reproducibility and traceability.

740
Multi-Selectmedium

A company uses Vertex AI Model Monitoring. Which two configuration options can be set to reduce false positive drift alerts?

Select 2 answers
A.Use a sample percentage of predictions
B.Set a shorter alerting window
C.Increase the drift threshold
D.Decrease the drift threshold
E.Enable feature attribution monitoring
AnswersA, C

Monitoring only a sample percentage of predictions reduces the volume of data compared against the baseline, dampening statistical noise that triggers spurious drift alerts. This satisfies the goal of lowering false positives without disabling monitoring entirely.

Why this answer

Option A (Use a sample percentage of predictions) is correct because sampling only a subset of incoming prediction requests for drift analysis reduces the volume of data evaluated, smoothing out minor statistical fluctuations that would otherwise trigger spurious drift alerts. Option C (Increase the drift threshold) is correct because raising the threshold means the observed drift must be larger before an alert fires, directly filtering out small, benign deviations and lowering false positives. Option B (Set a shorter alerting window) is wrong because a shorter window captures less data and is more sensitive to noise, which typically increases rather than reduces false alerts.

Option D (Decrease the drift threshold) is wrong because a lower threshold makes alerts fire on smaller deviations, producing more false positives. Option E (Enable feature attribution monitoring) is wrong because feature attribution explains which features drive predictions; it is an explainability capability, not a mechanism for reducing false positive drift alerts.

Exam trap

Google Cloud often tests the misconception that increasing sensitivity (lowering thresholds or shortening windows) reduces false positives, when in fact the opposite is true—these actions increase alert volume and false positives.

741
Matchingmedium

Match each MLOps practice to its description.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts
Matches

Continuous integration and deployment for ML pipelines

Track and manage different model iterations

Monitor for changes in data or model performance over time

Schedule or trigger model retraining based on conditions

Compare model versions in production with traffic splitting

Why these pairings

This matching question requires associating each MLOps practice (CI/CD, Model Monitoring, Data Versioning) with its correct description. The correct matches are: CI/CD automates building, testing, and deploying ML models (option A); Model Monitoring continuously observes model performance and detects data drift (option C); Data Versioning manages and tracks changes to datasets over time (option E). Common mistakes include confusing CI/CD with monitoring or versioning, or assigning model monitoring to data versioning tasks.

The wrong options (B, D, F) are incorrect because they swap responsibilities: B wrongly attributes monitoring to CI/CD, D assigns versioning to monitoring, and F assigns CI/CD to versioning.

742
MCQmedium

You need to query a Vertex AI Vector Search index for nearest neighbours. The index is deployed on an endpoint. Which API method should you use to perform the query?

A.projects.locations.indexEndpoints.findNeighbors
B.projects.locations.indexes.match
C.projects.locations.indexes.query
D.projects.locations.endpoints.predict
AnswerA

Queries go to the index endpoint where the index is deployed, using findNeighbors. A request names the deployed index ID and includes one or more query vectors, the number of neighbours to return, and optional filters on token or numeric attributes. The response lists neighbour IDs with distances. Client libraries wrap it, for example MatchingEngineIndexEndpoint.find_neighbors() in the Vertex AI Python SDK.

Why this answer

The correct API method to query a deployed Vertex AI Vector Search index for nearest neighbors is `projects.locations.indexEndpoints.findNeighbors`. This method is specifically designed for vector similarity search against an index endpoint, returning the nearest neighbors for a given query vector. The other options either target the wrong resource (indexes instead of indexEndpoints) or use methods intended for different purposes like model prediction.

Exam trap

The exam often tests the distinction between model prediction endpoints and vector search endpoints, so the trap here is confusing the `predict` method (for model inference) with the `findNeighbors` method (for vector similarity search), leading candidates to incorrectly select option D.

How to eliminate wrong answers

Option B is wrong because `projects.locations.indexes.match` is not a valid API method; the correct method for matching against an index is `findNeighbors` on the index endpoint. Option C is wrong because `projects.locations.indexes.query` does not exist; the query operation for vector search is performed via the index endpoint, not directly on the index resource. Option D is wrong because `projects.locations.endpoints.predict` is used for online prediction from a deployed model, not for querying a vector search index.

743
MCQhard

You are deploying a model to a Vertex AI Endpoint that must serve predictions with a strict 50 ms latency SLA. The model is a custom container that loads a large model file from Cloud Storage at startup. You notice that the first few predictions after a new deployment are slow, and sometimes the endpoint scales up and the new replicas also have slow first predictions. What should you do to reduce this cold-start latency?

A.Bake the model file into the custom container image so that it does not need to be downloaded from Cloud Storage at startup.
B.Increase the minimum number of replicas and enable autoscaling with a lower target utilization so that replicas are always warm.
C.Configure the endpoint to use a pre-built container instead of a custom container so that the model is loaded more efficiently.
D.Use a larger machine type for the endpoint so that the model file is downloaded faster and the model loads more quickly.
AnswerA

Embedding the model file in the container image removes the Cloud Storage download from the startup path, which is often the dominant cause of cold-start latency. The container image is cached on the host, so new replicas can start faster and serve predictions within the SLA. This is a common technique for latency-sensitive custom containers on Vertex AI.

Why this answer

The most direct way to reduce cold-start latency is to eliminate the need to download the large model file at startup by baking it into the container image. This removes a major source of delay for new replicas. The other options either do not address the startup download, add cost without solving the root cause, or are not applicable to custom models.

Exam trap

The trap here is focusing on autoscaling or machine size when the real cold-start bottleneck is the model file download at container startup.

744
MCQhard

A Vertex AI Endpoint hosts a model that must serve predictions with a strict 99th percentile latency under 100 ms. The model is a large TensorFlow model that processes images. During load testing, you observe that p99 latency spikes to 300 ms when batch size exceeds 1. You need to meet the latency SLO while maintaining reasonable throughput. What should you do?

A.Enable dynamic batching with a small maximum batch size and a short timeout.
B.Increase the batch size further to amortize overhead and improve throughput.
C.Increase the number of replicas and keep batch size at 1.
D.Switch to a CPU-only machine type with more cores to parallelize inference.
AnswerA

Dynamic batching groups multiple requests into a single inference call, improving throughput, while a small maximum batch size and short timeout bound the added latency. This keeps p99 under the SLO by preventing large batches that caused the 300 ms spike, and it balances throughput and latency better than fixed batch size of 1. It directly addresses the observed trade-off.

Why this answer

The latency spike is caused by large batch sizes. Dynamic batching with a small maximum and short timeout limits how long requests wait and how many are combined, keeping p99 under 100 ms while still batching enough to improve throughput. Simply adding replicas or changing hardware does not resolve the batch-size-induced tail latency.

Exam trap

The trap here is assuming that more replicas or a bigger batch size will fix latency, when the spike is specifically caused by large batches.

745
Multi-Selectmedium

An organization wants to implement central governance for ML models across teams. Which TWO services should they use together to achieve model versioning, lineage, and deployment management? (Select 2)

Select 2 answers
A.Vertex AI Feature Store
B.Vertex AI Model Registry
C.Vertex AI Metadata
D.Vertex AI Experiments
E.Cloud Data Catalog
AnswersB, C

Vertex AI Model Registry provides central model versioning, lineage tracking and deployment management across teams, satisfying the governance requirement. It organises models into versioned lineages and integrates with endpoints, giving one governed catalogue for all teams' models.

Why this answer

Vertex AI Model Registry (B) is correct because it provides a central repository for managing the lifecycle of ML models, including versioning, tracking model artifacts, and managing deployment to endpoints, which directly satisfies the model versioning and deployment management requirements. Vertex AI Metadata (C) is correct because it captures and stores metadata about artifacts, executions, and contexts, enabling lineage tracking across the ML workflow so teams can trace how models were produced and what data or training runs contributed to them. Together, Model Registry handles versioning and deployment while Metadata provides the lineage and governance context needed for central oversight.

Vertex AI Feature Store (A) is for organizing, serving, and sharing feature data, not for model versioning or deployment management. Vertex AI Experiments (D) is for tracking and comparing training experiment runs and metrics, which supports experimentation but not centralized model deployment governance. Cloud Data Catalog (E) is a data discovery and metadata management service for data assets, not a model registry or ML lineage/deployment tool.

746
MCQhard

A team is building a CI/CD pipeline for an ML model. They want to automatically trigger a Vertex AI pipeline for retraining whenever new training data arrives in a Cloud Storage bucket, but only if a specific Pub/Sub notification is published by a data ingestion process. Which approach meets these requirements with minimal operational overhead?

A.Use Cloud Scheduler to run a job every hour that checks for new files in Cloud Storage and starts the pipeline if new files exist.
B.Configure a Cloud Build trigger that listens to the Pub/Sub topic and executes a build step that submits the pipeline run.
C.Use Eventarc to route the Pub/Sub notification to a Cloud Function that calls the Vertex AI pipeline creation API.
D.Create a Dataflow streaming pipeline that reads from Pub/Sub and triggers the Vertex AI pipeline via a custom sink.
AnswerC

Eventarc natively consumes Pub/Sub messages and delivers them to a Cloud Function, which then invokes the Vertex AI pipeline creation API. This event-driven path avoids polling or custom infrastructure, meeting the trigger condition with minimal operational overhead.

Why this answer

Eventarc can directly listen to a Pub/Sub topic and route matching messages to a Cloud Function, which then calls the Vertex AI pipeline creation API. This serverless approach triggers the pipeline only when the specific Pub/Sub notification is published, meeting the requirement with zero infrastructure to manage and no polling overhead.

Exam trap

The trap here is that candidates may over-engineer the solution by choosing Dataflow (Option D) because it sounds 'streaming' and 'real-time', but the simplest serverless event-driven approach (Eventarc + Cloud Function) meets the requirement with minimal operational overhead.

How to eliminate wrong answers

Option A is wrong because Cloud Scheduler polling every hour introduces latency (up to 1 hour) and does not respond to the Pub/Sub notification; it also requires managing a scheduled job and checking for new files, which adds operational overhead and may miss the specific trigger condition. Option B is wrong because Cloud Build triggers are designed for source code changes (e.g., Git commits) and cannot directly listen to a Pub/Sub topic for arbitrary messages; even if configured with a Pub/Sub trigger, Cloud Build is intended for building containers, not for orchestrating ML pipeline runs, and would require extra steps to invoke Vertex AI. Option D is wrong because a Dataflow streaming pipeline is overkill for this simple event-driven trigger; it introduces a persistent streaming job with associated cost and complexity, whereas a lightweight Cloud Function is sufficient and more cost-effective.

747
MCQmedium

A company wants to build a recommendation system that suggests products to users based on their past purchase history. They have a large dataset of user-item interactions in BigQuery and want to use a low-code approach. They decide to use BigQuery ML's matrix factorization model. Which SQL statement correctly creates such a model?

A.CREATE MODEL `project.dataset.recommender` OPTIONS(model_type='kmeans', num_clusters=10) AS SELECT user_id, product_id, rating FROM `project.dataset.interactions`
B.CREATE MODEL `project.dataset.recommender` OPTIONS(model_type='logistic_reg', user_col='user_id', item_col='product_id', rating_col='rating') AS SELECT user_id, product_id, rating FROM `project.dataset.interactions`
C.CREATE MODEL `project.dataset.recommender` OPTIONS(model_type='matrix_factorization', user_col='user_id', item_col='product_id', rating_col='rating') AS SELECT user_id, product_id, rating FROM `project.dataset.interactions`
D.CREATE MODEL `project.dataset.recommender` OPTIONS(model_type='matrix_factorization', input_label_cols=['rating']) AS SELECT user_id, product_id, rating FROM `project.dataset.interactions`
AnswerC

This statement correctly creates a matrix factorization model in BigQuery ML. It specifies the model type as matrix_factorization and identifies the user column, item column, and rating column. The SELECT statement provides the training data with user-item interactions and ratings. This is the standard syntax for building a recommendation model using collaborative filtering in BigQuery ML.

Why this answer

The correct SQL statement creates a matrix factorization model in BigQuery ML, specifying the user column, item column, and rating column. This model uses collaborative filtering to learn latent factors for users and items, enabling personalized recommendations. It is a low-code solution that requires only SQL and scales to large datasets, making it ideal for the company's needs.

Exam trap

The trap here is using incorrect options like input_label_cols for matrix factorization, which requires user_col, item_col, and rating_col.

748
MCQeasy

A media company wants to transcribe audio files from customer support calls into text for analysis. The audio is in English with clear speech and no background noise. They want a quick solution with no ML model training. Which Google Cloud service should they use?

A.Translation API to translate the audio
B.AutoML NLP to train a transcription model
C.Vertex AI Workbench to train a custom speech recognition model
D.Speech-to-Text API with the latest_long model
AnswerD

The latest_long model suits extended support-call audio, delivering accurate English transcription without any model training. It satisfies the stem's demand for a quick, pre-trained solution, unlike custom models requiring data and tuning. Speech-to-Text handles clear speech directly, so no ML expertise or training pipeline is needed.

Why this answer

The Speech-to-Text API is Google Cloud's fully managed, pre-trained automatic speech recognition (ASR) service that requires no model training. The latest_long model is specifically optimized for transcribing long-form audio content such as customer support calls, providing high accuracy for clear English speech. Since the audio is clear with no background noise and the company wants a quick, training-free solution, Speech-to-Text API with latest_long is the ideal fit.

Exam trap

PMLE often tests the distinction between pre-trained APIs and custom training services; candidates may incorrectly assume that any ML task requires training a custom model, overlooking that Speech-to-Text API is a ready-to-use pre-trained service.

How to eliminate wrong answers

Option A is wrong because the Translation API translates text between languages and cannot process audio input at all. Option B is wrong because AutoML NLP is designed for text classification, entity extraction, and sentiment analysis—not audio transcription—and it would require labeled training data. Option C is wrong because Vertex AI Workbench is a notebook-based development environment for building and training custom ML models, which contradicts the requirement for no model training and a quick solution.

749
MCQmedium

You have a custom model deployed on a Vertex AI endpoint that receives online prediction requests. The model expects input features in a specific order, but clients sometimes send features in a different order. You want to ensure that the endpoint consistently receives correctly ordered features without modifying every client. What should you do?

A.Create a new endpoint for each client that expects the client's specific feature order.
B.Implement a preprocessing function in the model's serving signature that reorders the input features before prediction.
C.Configure the endpoint to reject requests with incorrectly ordered features and return an error message to clients.
D.Use a Vertex AI Feature Store to serve features to the model, ensuring that features are always in the correct order.
AnswerB

Adding a preprocessing step in the serving signature allows the endpoint to accept raw input and reorder features internally. This centralizes the logic, so clients don't need to change. Vertex AI custom containers can include a preprocessing function as part of the model's serving logic, ensuring consistent feature order regardless of client input. This is a robust solution that scales with the endpoint.

Why this answer

The most effective solution is to incorporate feature reordering into the model's serving logic. By adding a preprocessing function in the serving signature, the endpoint can accept features in any order and rearrange them correctly before inference. This centralizes the logic, avoids client-side changes, and ensures consistent predictions.

It is a standard practice in Vertex AI custom containers to include such preprocessing.

Exam trap

The trap here is thinking that Feature Store or multiple endpoints will solve the ordering problem, when the simplest fix is to handle reordering within the model's serving code.

750
Multi-Selecthard

Which TWO actions are recommended to detect and mitigate data drift in a production ML system on Vertex AI?

Select 2 answers
A.Deploy multiple models and use an ensemble to average predictions
B.Manually review model predictions daily
C.Automatically retrain the model when drift exceeds thresholds
D.Set up Vertex AI Model Monitoring to alert on feature distribution changes
E.Monitor prediction errors and flag when confidence is low
AnswersC, D

Automated retraining directly satisfies the mitigation requirement: when Vertex AI Model Monitoring flags drift beyond configured thresholds, a triggered pipeline retrains on recent data, restoring alignment between the model and the shifted production distribution. Detection alone is insufficient; this closes the loop by acting on the drift signal rather than merely reporting it.

Why this answer

Option D is correct because Vertex AI Model Monitoring is the purpose-built service for detecting data drift in production; it continuously analyzes incoming prediction requests against a baseline and alerts when feature distribution changes (e.g., training-serving skew or drift) exceed configured thresholds. Option C is correct because automated retraining triggered when drift exceeds thresholds is the recommended mitigation action, closing the loop from detection to remediation so the model stays aligned with current data. Together, D provides detection and C provides mitigation, which is exactly what the question asks for.

Option A is not recommended because ensembling multiple models addresses prediction variance/accuracy, not data drift detection or mitigation. Option B is not recommended because manual daily review does not scale and cannot reliably quantify distributional drift. Option E is not recommended because monitoring prediction errors or low confidence detects performance degradation but does not specifically identify feature distribution drift or mitigate it.

Exam trap

Google Cloud often tests the distinction between drift detection (monitoring input distributions) and model performance monitoring (tracking prediction errors or confidence), leading candidates to confuse E with a valid drift mitigation technique.

Page 9

Page 10 of 11

Page 11

All pages