Courseiva

Google Professional Machine Learning Engineer (PMLE) — Questions 76–150

990 questions total · 14pages · All types, answers revealed

Take a mock examExam hub
Page 1

Page 2 of 14

Page 3
76
MCQmedium

A data scientist has deployed a model with Vertex AI Endpoints and enabled request/response logging to BigQuery. They want to compute a confusion matrix over time to monitor model quality. What should they do?

A.Use Vertex AI Model Monitoring to automatically generate confusion matrices
B.Use Cloud Monitoring to create a confusion matrix dashboard
C.Upload ground truth labels to BigQuery and join with prediction logs, then compute confusion matrix in a scheduled query
D.Enable Vertex AI Explainability to get confusion matrix
AnswerC

Correct: This is the standard approach for model quality monitoring.

Why this answer

To compute a confusion matrix, ground truth labels are needed. The team can upload ground truth labels to BigQuery and join with prediction logs to compare predictions vs actuals.

Full explanation →
77
MCQeasy

A machine learning model deployed on Vertex AI is returning erroneous predictions. The team needs to investigate the root cause by examining the prediction request and response details. Which Google Cloud tool is best suited for this?

A.Cloud Monitoring
B.Cloud Debugger
C.Cloud Logging
D.Cloud Trace
AnswerC

Cloud Logging can capture structured logs from Vertex AI predictions, including request and response data for analysis.

Why this answer

Cloud Logging is the correct tool because it captures detailed logs of prediction requests and responses, including input features, model outputs, and any errors. By examining these logs, the team can trace the exact data flow and identify discrepancies causing erroneous predictions, such as data preprocessing issues or model version mismatches.

Exam trap

The trap here is that candidates confuse Cloud Monitoring (which shows aggregate health metrics) with Cloud Logging (which provides granular request/response data), leading them to choose a tool that cannot reveal the specific prediction details needed for root cause analysis.

How to eliminate wrong answers

Option A is wrong because Cloud Monitoring focuses on metrics and alerting (e.g., latency, error rates) but does not capture the content of individual prediction requests or responses. Option B is wrong because Cloud Debugger is designed for inspecting live application code state (e.g., variable values) in production, not for logging request/response payloads of ML predictions. Option D is wrong because Cloud Trace provides latency analysis and distributed tracing of requests across services, but it does not log the actual prediction data or response details needed to debug prediction errors.

Full explanation →
78
MCQhard

A company deploys a model on Vertex AI Endpoints and configures Vertex AI Model Monitoring with a sampling rate of 0.1 and monitoring frequency of every hour. They notice that the monitoring alert fires only after several hours of drift. What is the most likely cause?

A.The alerting threshold is set too high; it should be lowered
B.The monitoring frequency is too low; it should be every minute
C.The model endpoint is not receiving enough traffic to generate a statistically significant sample
D.The sampling rate is too low, causing the drift detection algorithm to require more time to accumulate a representative distribution
AnswerD

Correct: low sampling rate delays detection.

Why this answer

A low sampling rate (0.1) means only 10% of predictions are analyzed, which reduces the statistical power to detect drift quickly. Increasing the sampling rate improves detection speed.

Full explanation →
79
Multi-Selecthard

A company is using Vertex AI Pipelines for ML workflows. They want to implement best practices for idempotent components and data passing. Which THREE practices should they adopt?

Select 3 answers
A.Pass large datasets between components using GCS URIs instead of in-memory values.
B.Avoid hard-coding file paths; use pipeline parameters to pass URIs.
C.Read data into memory in the first component and pass the in-memory object to subsequent components.
D.Use global variables in the pipeline code to store intermediate results.
E.Design components to be idempotent so that the same input always produces the same output.
AnswersA, B, E

GCS URIs allow for scalable, cacheable data passing.

Why this answer

Vertex AI Pipelines components run in isolated containers; passing large datasets in-memory would exceed memory limits and cause failures. Using GCS URIs allows components to read/write data directly from Cloud Storage, which is the recommended pattern for handling large artifacts in Kubeflow Pipelines (the underlying orchestrator). This approach also enables caching and parallel execution since components only depend on the URI, not on the state of previous containers.

Exam trap

A common misconception in Vertex AI Pipelines is that in-memory data passing is acceptable in containerized components, but the correct pattern is to use GCS URIs and artifact references to ensure idempotency and scalability.

Full explanation →
80
MCQeasy

An ML engineer is designing a CI/CD pipeline for ML models using Cloud Build and Cloud Deploy. They want to automatically test model performance on a validation set before promoting to production. Which step should be included in the CI/CD pipeline?

A.Run unit tests on the training code
B.Use Cloud Composer to schedule evaluation
C.Deploy to production immediately after training
D.Train the model in the CI/CD pipeline
E.Run a Vertex AI Pipeline for model evaluation and register the model only if metrics exceed thresholds
AnswerE

Implements a quality gate.

Why this answer

It directly integrates model evaluation into the CI/CD pipeline using Vertex AI Pipelines, which allows automated validation of model performance against predefined thresholds before promotion. This ensures that only models meeting quality criteria are deployed, aligning with MLOps best practices for gated promotions.

Exam trap

Google Cloud often tests the distinction between code testing (unit tests) and model validation (performance metrics), leading candidates to choose A because they conflate software testing with ML evaluation.

How to eliminate wrong answers

Option A is wrong because unit tests on training code verify code correctness but do not assess model performance on a validation set, which is the requirement. Option B is wrong because Cloud Composer is an orchestration tool for workflows, not a CI/CD step for automatic model evaluation before promotion; it would introduce scheduling latency rather than inline gating. Option C is wrong because deploying immediately after training bypasses validation, risking production degradation from underperforming models.

Option D is wrong because training the model in the CI/CD pipeline is possible but does not include the evaluation step needed to gate promotion; it focuses on the training process itself, not validation.

Full explanation →
81
MCQmedium

A team wants to share feature definitions across multiple projects in their organization using Vertex AI Feature Store. What is the recommended approach?

A.Export features to BigQuery datasets in each project
B.Use Vertex AI Feature Store's feature view for cross-project access
C.Create separate feature stores in each project and synchronize them with Dataflow
D.Use a centralized feature store in a shared project and grant access to other projects via IAM
AnswerD

Centralized feature store with IAM enables controlled sharing.

Why this answer

Vertex AI Feature Store supports cross-project sharing by registering the feature store at the organization level, allowing features to be accessed from different projects.

Full explanation →
82
MCQmedium

A team is scaling a prototype ML model to production on Vertex AI. The model was developed using scikit-learn and requires custom preprocessing. They want to minimize operational overhead and ensure consistency between training and serving. Which approach should they use?

A.Train on a local machine and upload the model artifacts to Cloud Storage, then create an endpoint with a pre-built container.
B.Use a pre-built Vertex AI container for scikit-learn and provide a custom training Python package with preprocessing code included.
C.Deploy the model as a custom prediction routine on Vertex AI Endpoints with a custom container.
D.Export the model as a .pkl file and use Vertex AI's 'Import Model' with a default container for inference.
AnswerB

Pre-built containers reduce overhead; custom package handles preprocessing, ensuring consistency.

Why this answer

Using a pre-built Vertex AI container for scikit-learn with a custom training Python package ensures that the same preprocessing code runs during both training and serving, minimizing operational overhead. This approach leverages Vertex AI's managed infrastructure to handle scaling, monitoring, and consistency without requiring custom container maintenance.

Exam trap

The trap here is that candidates often assume a pre-built container cannot handle custom preprocessing, leading them to choose a custom container (Option C) or a simpler import (Option D), but Vertex AI allows embedding preprocessing in the training package or model artifact to maintain consistency with minimal overhead.

How to eliminate wrong answers

Option A is wrong because training on a local machine and uploading model artifacts to Cloud Storage, then creating an endpoint with a pre-built container, does not guarantee consistency between training and serving preprocessing logic, as the preprocessing code is not bundled with the model. Option C is wrong because deploying the model as a custom prediction routine with a custom container introduces unnecessary operational overhead for a scikit-learn model that can be served with a pre-built container, and it requires building and maintaining a custom Docker image. Option D is wrong because exporting the model as a .pkl file and using Vertex AI's 'Import Model' with a default container for inference does not include custom preprocessing code, leading to potential inconsistencies between training and serving.

Full explanation →
83
MCQeasy

A non-technical user wants to build a binary classification model using Vertex AI. Which UI should they use?

A.Vertex AI AutoML
B.Vertex AI Workbench
C.Vertex AI Pipelines
D.Vertex AI Prediction
AnswerA

Correct: No-code UI for training.

Why this answer

Vertex AI AutoML is the correct choice because it provides a no-code graphical user interface specifically designed for non-technical users to build, train, and deploy machine learning models, including binary classification models, without writing any code. It automates the entire ML pipeline—feature engineering, model selection, hyperparameter tuning—allowing users to simply upload labeled data and get a production-ready model.

Exam trap

Google Cloud often tests the distinction between 'building/training' tools (AutoML) and 'deploying/serving' tools (Prediction), leading candidates to mistakenly choose Vertex AI Prediction because they confuse the deployment phase with the model creation phase.

How to eliminate wrong answers

Option B is wrong because Vertex AI Workbench is a Jupyter notebook-based development environment intended for data scientists and ML engineers who write custom code, not for non-technical users seeking a low-code solution. Option C is wrong because Vertex AI Pipelines is a tool for orchestrating and automating ML workflows using code-defined pipelines (e.g., Kubeflow Pipelines SDK), requiring programming skills to define steps and dependencies. Option D is wrong because Vertex AI Prediction is a serving endpoint for deploying and running inference on already-trained models, not a UI for building or training models from scratch.

Full explanation →
84
MCQhard

A model deployed on Vertex AI Endpoints returns predictions, but the performance metrics (e.g., AUC) degrade over time. The input data distribution is shifting. The team wants to detect and alert on this drift automatically. Which set of actions should they take?

A.Schedule a batch prediction job daily and compare with ground truth
B.Enable Vertex AI Model Monitoring for feature drift and set up alerts via Cloud Monitoring
C.Use Vertex AI Explainable AI to understand predictions
D.Implement custom logging in the serving container and use BigQuery for analysis
AnswerB

Model Monitoring automatically calculates drift metrics and can trigger alerts when drift exceeds thresholds.

Why this answer

Vertex AI Model Monitoring can monitor for feature distribution drift and skew, and can be configured to send alerts via Cloud Monitoring. Option A is part of model interpretation, not drift detection. Option C requires ground truth labels, which may not be available immediately.

Option D is manual and not automated.

Full explanation →
85
MCQmedium

A company wants to track the cost of their Vertex AI prediction endpoint. They use a custom machine type with 1 n1-standard-4 (4 vCPU, 15 GB memory) and 1 NVIDIA T4 GPU. The endpoint is configured for automatic scaling with min=1, max=5 replicas. Which cost monitoring approach should they use?

A.Use Cloud Billing budget alerts and export cost data to BigQuery for analysis.
B.Calculate cost manually based on replica count and GPU hours from endpoint logs.
C.Use Vertex AI Experiments to track cost.
D.Monitor only the CPU utilisation metrics to infer cost.
AnswerA

Correct: Cloud Billing provides accurate cost tracking and alerts.

Why this answer

Vertex AI prediction costs are composed of per-hour per-replica compute and GPU charges plus per-request usage. The best approach is to use Cloud Billing export to BigQuery and query cost data by service and SKU, or use the Vertex AI cost tables in the console.

Full explanation →
86
Multi-Selectmedium

A data scientist wants to use AutoML Tables to build a binary classification model for loan default prediction. The dataset has 200 features and 1 million rows, with highly imbalanced classes. Which TWO options should they consider? (Choose 2)

Select 2 answers
A.Enable automatic feature engineering
B.Set the target column to 'default'
C.Disable hyperparameter tuning to save cost
D.Use Manual data split
E.Use the 'maximize AUC' optimisation objective
AnswersB, E

Why this answer

For binary classification, the target column must be set. For imbalanced classes, 'maximize AUC' is recommended. AutoML Tables automatically handles feature engineering and hyperparameter tuning.

Manual split is optional.

Full explanation →
87
Multi-Selecthard

Which TWO strategies help ensure data consistency when multiple teams are contributing features to a shared Vertex AI Feature Store?

Select 2 answers
A.Each team should create their own feature store to avoid conflicts.
B.Use only batch ingestion to keep features synchronized.
C.Define and enforce feature schemas using the Feature Store API.
D.Allow each team to independently define feature engineering logic.
E.Set up monitoring and alerting on feature value distributions to detect drift.
AnswersC, E

Schemas ensure consistent data types and values.

Why this answer

Defining and enforcing feature schemas using the Vertex AI Feature Store API ensures that all teams adhere to a consistent data structure (e.g., fixed feature names, data types, and value ranges). This prevents schema drift and ingestion conflicts, which are common when multiple teams independently push features to the same feature store. Without schema enforcement, one team might inadvertently change a feature's data type or add unexpected values, breaking downstream models.

Exam trap

Google Cloud often tests the misconception that 'separate stores' or 'batch-only ingestion' are valid consistency strategies, when in fact the correct approach is centralized schema governance with monitoring to detect drift.

Full explanation →
88
Multi-Selecthard

A financial institution uses a machine learning model to approve loans. They must monitor for fairness and bias. Which THREE Google Cloud tools or features can help them achieve this? (Choose 3.)

Select 3 answers
A.What-If Tool
B.Vertex AI Model Monitoring
C.Cloud Data Loss Prevention
D.Cloud Healthcare API
E.Explainable AI
AnswersA, B, E

The What-If Tool allows testing different scenarios and slicing by protected attributes to evaluate fairness.

Why this answer

The What-If Tool (WIT) is a Google Cloud tool integrated with Vertex AI that allows users to analyze model behavior across different subsets of data, such as demographic groups. It provides interactive visualizations to test how changes in input features affect predictions, enabling fairness assessments by comparing performance metrics across groups. This directly supports monitoring for bias in loan approval decisions.

Exam trap

Google Cloud often tests the distinction between data security tools (like DLP) and ML fairness tools, so candidates mistakenly select Cloud DLP thinking it addresses bias because it handles sensitive attributes, but DLP does not analyze model predictions or fairness metrics.

Full explanation →
89
MCQhard

A large enterprise has multiple ML models deployed in production across different regions. They want to implement a centralized monitoring dashboard that tracks key performance indicators such as prediction accuracy, latency, and error rates for all models, with the ability to drill down into individual model versions. Which approach best meets these requirements?

A.Use Vertex AI Experiments to log metrics and compare across runs
B.Use Cloud Logging to search logs from each model and create a dashboard
C.Use BigQuery to store prediction logs and then visualize in Looker
D.Use Cloud Monitoring with custom metrics reported by each model deployment, and create a unified dashboard with filterable resources
AnswerD

Cloud Monitoring supports custom metrics and dashboards that can be filtered by resource labels (e.g., model name, version), providing centralized visibility and drill-down capability.

Why this answer

Cloud Monitoring with custom metrics allows each model deployment to report key performance indicators (e.g., prediction accuracy, latency, error rates) as metric time series. These custom metrics can be aggregated into a single unified dashboard, and the dashboard can be configured with filterable resources (e.g., region, model version) to enable drill-down into individual model versions. This approach provides centralized, real-time monitoring without relying on log-based or batch analytics.

Exam trap

Google Cloud often tests the distinction between logging (Cloud Logging) and monitoring (Cloud Monitoring), where candidates mistakenly think log-based dashboards are sufficient for real-time KPI tracking, ignoring the need for structured, low-latency custom metrics.

How to eliminate wrong answers

Option A is wrong because Vertex AI Experiments is designed for tracking and comparing training runs (e.g., hyperparameter tuning), not for real-time monitoring of deployed models in production across regions. Option B is wrong because Cloud Logging is a log management service that requires parsing unstructured log entries to extract metrics, which is inefficient for real-time KPIs and lacks native metric aggregation and dashboard drill-down capabilities. Option C is wrong because BigQuery is a data warehouse for storing and querying large datasets, and while Looker can visualize it, this approach introduces latency from batch loading and is not designed for real-time monitoring of live model deployments.

Full explanation →
90
MCQeasy

Refer to the exhibit. A data scientist runs this Vertex AI training job code. What will be the outcome?

A.The job runs as a regular custom training with 10 replicas.
B.A HyperparameterTuningJob is created and runs trials.
C.A CustomJob is created with hyperparameters from the spec.
D.The job fails because parallel_trial_count cannot be less than max_trial_count.
AnswerB

The hyperparameter_tuning_job_spec instructs Vertex AI to run tuning.

Why this answer

The code uses `HyperparameterTuningJob` with `parallel_trial_count=1` and `max_trial_count=10`. This creates a hyperparameter tuning job that runs up to 10 trials, each trial being a separate training run with different hyperparameter values. The `parallel_trial_count=1` means trials run sequentially, not in parallel, but this is valid and does not cause failure.

Exam trap

Google Cloud often tests the misconception that `parallel_trial_count` must be equal to or greater than `max_trial_count`, when in reality it can be any value from 1 to `max_trial_count`, and sequential trials are perfectly valid.

How to eliminate wrong answers

Option A is wrong because the code explicitly creates a `HyperparameterTuningJob`, not a regular custom training job; a regular custom training job would use `CustomJob` or `CustomContainerTrainingJob` without hyperparameter tuning parameters. Option C is wrong because a `CustomJob` does not accept hyperparameter tuning parameters like `parallel_trial_count` or `max_trial_count`; those are specific to `HyperparameterTuningJob`. Option D is wrong because `parallel_trial_count` can be less than `max_trial_count`; the constraint is that `parallel_trial_count` must be less than or equal to `max_trial_count`, and 1 ≤ 10 is valid.

Full explanation →
91
MCQmedium

A financial services company uses BigQuery ML to build a logistic regression model for fraud detection. The model is trained on the last 6 months of transaction data (about 50 million rows). After deployment, the fraud detection team notices a high false positive rate, causing customer dissatisfaction and extra manual review costs. The model is currently retrained monthly. The team wants to reduce false positives without sacrificing recall. They have access to real-time transaction streaming and can compute new features quickly. What is the most effective approach?

A.Replace logistic regression with gradient boosted trees (XGBoost) in BigQuery ML
B.Use Vertex AI AutoML Tables to train a more complex model
C.Increase retraining frequency to daily
D.Add engineered features like rolling transaction count and velocity per user
AnswerD

New features provide more signal to reduce false positives.

Why this answer

Adding engineered features like rolling transaction count and velocity per user directly addresses the high false positive rate by providing the logistic regression model with more discriminative temporal signals. Since the team has access to real-time streaming and can compute features quickly, these features capture behavioral patterns that reduce false positives without sacrificing recall, and logistic regression can effectively leverage them with proper feature engineering.

Exam trap

The trap here is that candidates often assume a more complex model (XGBoost or AutoML) is always better for reducing false positives, but the question specifically tests the principle that feature engineering—especially temporal aggregations—is the most effective lever when the model is already appropriate and data is streaming.

How to eliminate wrong answers

Option A is wrong because replacing logistic regression with gradient boosted trees (XGBoost) may improve model capacity but does not directly target the root cause of high false positives—lack of informative features—and could increase complexity without guaranteed recall preservation. Option B is wrong because using Vertex AI AutoML Tables to train a more complex model similarly addresses model complexity rather than feature insufficiency, and may introduce overfitting or latency issues without solving the false positive problem. Option C is wrong because increasing retraining frequency to daily does not change the underlying feature set or model architecture; it only refreshes weights on the same features, which will not reduce false positives if the model lacks discriminative signals.

Full explanation →
92
Multi-Selectmedium

A machine learning engineer is designing an ML pipeline on Vertex AI. The pipeline includes multiple steps: data validation, preprocessing, training, evaluation, and deployment. The engineer wants to ensure that if the data validation step fails due to schema mismatch, the pipeline stops immediately and does not proceed. Additionally, they want to reuse the preprocessed data from a previous successful run if the source data hasn't changed. Which two configurations should they use? (Choose two.)

Select 2 answers
A.Use a custom exit handler in the data validation step to abort the pipeline.
B.Set the 'on_failure' parameter of the data validation component to 'Stop'.
C.Use conditional branches to check the output of data validation before proceeding.
D.Set the 'cache' option for the preprocessing step to True.
E.Enable 'skip_if_successful' on the preprocessing step.
AnswersB, D

Setting on_failure='Stop' immediately stops the pipeline if the component fails.

Why this answer

The correct options are B and D. Option B: Setting the 'on_failure' parameter of the data validation component to 'Stop' causes the pipeline to immediately abort when data validation fails, which meets the requirement. Option D: Setting 'cache' to True on the preprocessing step enables Vertex AI's caching mechanism, which reuses outputs from previous runs if the input data and component code are unchanged, effectively skipping reruns when source data hasn't changed.

Option A is incorrect because custom exit handlers are not a standard pipeline feature; the correct way to abort on failure is via the 'on_failure' parameter. Option C is incorrect because conditional branches add complexity and are not the simplest approach; the 'on_failure' parameter directly stops the pipeline. Option E is incorrect because 'skip_if_successful' is not a valid parameter; caching achieves the desired reuse behavior.

Full explanation →
93
MCQhard

A company uses Cloud Composer to orchestrate an ML pipeline. They notice that the pipeline occasionally fails because the Composer environment runs out of disk space on the worker nodes. The pipeline uses many large dependencies. What is the most effective long-term solution?

A.Mount a Cloud Storage bucket to the Composer workers using GCSFuse to store large artifacts externally.
B.Move the pipeline to Cloud Functions to avoid Composer's disk limitations.
C.Reduce the size of the Docker image used by the pipeline.
D.Increase the number of worker nodes in the Composer environment.
AnswerA

Keeps local disk usage low by offloading to Cloud Storage.

Why this answer

Mounting a Cloud Storage bucket via GCSFuse allows Composer workers to access large artifacts stored externally without consuming local disk space. This provides a scalable, durable, and cost-effective solution for handling large dependencies, as the pipeline can read/write directly to Cloud Storage, eliminating the disk space bottleneck on worker nodes.

Exam trap

Google Cloud often tests the misconception that scaling out (adding more nodes) solves disk space issues, but the real problem is per-node disk capacity, not overall cluster capacity.

How to eliminate wrong answers

Option B is wrong because Cloud Functions have a limited execution timeout (up to 60 minutes for HTTP functions, 540 seconds for background functions) and a maximum memory of 32GB, making them unsuitable for long-running ML pipelines with large dependencies. Option C is wrong because reducing the Docker image size only addresses the image storage, not the runtime disk space used by large artifacts during pipeline execution. Option D is wrong because increasing the number of worker nodes distributes the workload but does not increase the per-node disk capacity; each worker still has the same local disk limit, so the pipeline can still fail if a single worker runs out of space.

Full explanation →
94
Multi-Selecthard

A healthcare company uses AutoML Tables to predict patient readmission risk. The dataset contains 500,000 rows and 200 features, including patient demographics, lab results, and medical history. The model accuracy is lower than expected. The engineer wants to improve performance using low-code techniques. Which THREE actions are most effective? (Choose THREE.)

Select 3 answers
A.Increase the training time budget to the maximum allowed.
B.Remove highly correlated features using AutoML Tables' built-in feature importance analysis.
C.Engineer new features such as time since last admission and number of previous admissions.
D.Use a custom model architecture via AutoML Tables advanced options.
E.Enable automated handling of missing values and outliers in the dataset configuration.
AnswersB, C, E

Reduces noise and improves model generalization.

Why this answer

AutoML Tables provides built-in feature importance analysis that can identify and remove highly correlated features, which reduces noise and multicollinearity, often improving model performance without manual intervention. This is a low-code technique that leverages the platform's automated capabilities to streamline feature selection.

Exam trap

Google Cloud often tests the misconception that increasing training time or using custom architectures is a low-code solution, when in fact low-code techniques rely on platform automation like built-in feature engineering and data preprocessing, not manual tuning or custom coding.

Full explanation →
95
MCQeasy

Refer to the exhibit. A Vertex AI prediction endpoint is failing with a deadline exceeded error. The log shows the following. What is the most likely cause?

A.The prediction request is malformed
B.Insufficient CPU or memory for the load
C.The model is too large for the machine type
D.The model version is corrupted
AnswerB

High CPU and memory utilization indicate the machine type is inadequate for the prediction workload, leading to timeouts.

Why this answer

A deadline exceeded error in Vertex AI prediction endpoints typically indicates that the model is taking too long to respond, often due to insufficient CPU or memory resources for the current load. This causes the request to time out before the inference completes, as the underlying infrastructure cannot process the requests quickly enough.

Exam trap

Google Cloud often tests the distinction between deployment-time errors (like model size) and runtime errors (like timeout), so candidates mistakenly associate a deadline exceeded error with model corruption or malformed requests rather than resource constraints.

How to eliminate wrong answers

Option A is wrong because a malformed request would result in an invalid argument or bad request error (e.g., HTTP 400), not a deadline exceeded (HTTP 504) error. Option C is wrong because a model that is too large for the machine type would cause a resource exhaustion error at deployment time (e.g., 'Insufficient memory to load model'), not a runtime deadline exceeded error. Option D is wrong because a corrupted model version would cause model loading failures or prediction errors (e.g., 'Model not found' or 'Internal server error'), not a timeout-related deadline exceeded error.

Full explanation →
96
MCQeasy

You are monitoring a classification model that predicts loan default. The model was trained on data from 2020-2022. In 2023, the economic conditions changed, and the model's accuracy dropped significantly. Which monitoring approach would best help you detect this issue early?

A.Monitor the accuracy of the model on the latest batch of labeled data
B.Monitor feature distribution drift using KS test
C.Monitor the prediction distribution for significant shift from training distribution
D.Monitor the freshness of the training data
AnswerC

Prediction distribution shift can indicate concept drift even without labels.

Why this answer

Monitoring the prediction distribution for a significant shift from the training distribution directly detects changes in the model's output behavior, which is the earliest indicator of concept drift or data drift caused by economic changes. Unlike accuracy monitoring, this approach does not require labeled data, enabling real-time detection of performance degradation before ground truth labels become available.

Exam trap

The trap here is that candidates often choose monitoring feature drift (Option B) because it sounds technical, but they overlook that concept drift—a change in the relationship between features and the target—is better detected by monitoring prediction distribution shifts, not just feature distribution shifts.

How to eliminate wrong answers

Option A is wrong because monitoring accuracy on labeled data is a reactive approach that requires ground truth labels, which are often delayed or unavailable in real-time, making it too slow to detect early drift. Option B is wrong because monitoring feature distribution drift using the KS test only detects changes in input features, not the relationship between features and the target (concept drift), so it may miss shifts in the decision boundary caused by economic changes. Option D is wrong because monitoring the freshness of training data is a data management practice that does not directly detect model performance degradation or drift; it only ensures the training data is recent, not that the model is still valid under new conditions.

Full explanation →
97
MCQmedium

Your organization has a requirement to monitor fairness of an ML model that predicts loan approvals. You need to set up alerts if the model's predictions show bias against a protected group. Which tool on Google Cloud can you use to monitor this?

A.Cloud Vision API to analyze demographic data.
B.Vertex AI Model Monitoring with Fairness Indicators integration.
C.AutoML Tables fairness evaluation results from training.
D.Cloud DLP (Data Loss Prevention) to inspect input features for bias.
AnswerB

Fairness Indicators can be evaluated and monitored via Vertex AI Model Monitoring.

Why this answer

Vertex AI Model Monitoring with Fairness Indicators integration is the correct tool because it allows you to continuously monitor a deployed model's predictions for bias against protected groups (e.g., race, gender) by analyzing prediction distributions and setting alert thresholds. This is a post-deployment monitoring capability, not a training-time evaluation, and it directly addresses the requirement to set up alerts on live predictions.

Exam trap

The trap here is that candidates confuse training-time fairness evaluation (AutoML Tables) with post-deployment monitoring (Vertex AI Model Monitoring), or they mistakenly think data inspection tools like Cloud DLP or Vision API can perform bias analysis on predictions.

How to eliminate wrong answers

Option A is wrong because Cloud Vision API is an image analysis service for detecting objects, text, and faces in images; it has no capability to analyze demographic data or monitor ML model fairness. Option C is wrong because AutoML Tables fairness evaluation results are generated during model training, not for ongoing post-deployment monitoring; the question specifically requires setting up alerts on predictions, which is a monitoring, not training, task. Option D is wrong because Cloud DLP is designed to inspect and redact sensitive data (e.g., PII) in text, not to analyze model predictions for bias or set fairness alerts.

Full explanation →
98
MCQmedium

A company uses Vertex AI Pipelines to orchestrate an AutoML tabular training step followed by a BigQuery ML evaluation step. The pipeline fails because the output of the AutoML step (a model resource name) is not being passed to the BigQuery step. What is the most likely cause?

A.The AutoML training component is implemented as a Python function without proper artifact input/output annotations
B.The pipeline is using a custom pipeline root but the model is in a different region
C.The Vertex AI Pipeline Runner does not have permission to access AutoML models
D.The BigQuery ML evaluation component requires a service agent with Cloud SQL access
AnswerA

Kubeflow Pipelines requires artifact tracking for passing parameters.

Why this answer

In Vertex AI Pipelines, when using the Kubeflow Pipelines SDK, components must explicitly declare their inputs and outputs using type annotations (e.g., `Input[Model]`, `Output[Model]`) or via `@component` decorators with `outputs` specified. If the AutoML training step is implemented as a plain Python function without these annotations, the pipeline framework cannot serialize and pass the model resource name as an artifact to the downstream BigQuery ML evaluation step. This causes the pipeline to fail because the BigQuery step receives no valid model reference.

Exam trap

Google Cloud often tests the distinction between runtime permission errors (like IAM) and pipeline orchestration errors (like missing artifact passing), leading candidates to incorrectly choose a permissions-related option when the real issue is a component definition flaw.

How to eliminate wrong answers

Option B is wrong because a custom pipeline root or regional mismatch would cause storage or execution errors, not a failure to pass an output artifact between steps; the model resource name is a metadata artifact, not a storage path. Option C is wrong because permission issues would manifest as authorization errors (e.g., 403 Forbidden) when the pipeline runner tries to access the model, not as a missing output artifact; the error described is about data flow, not access control. Option D is wrong because BigQuery ML evaluation does not require Cloud SQL access; it uses BigQuery's own service agent and IAM permissions, and Cloud SQL is a separate database service irrelevant to this pipeline.

Full explanation →
99
MCQeasy

A financial company is building a fraud detection model. The dataset has 1% fraud cases and 99% legitimate transactions. Which technique should they use to handle the class imbalance?

A.Use class weighting or synthetic oversampling (SMOTE) during training
B.Randomly undersample the majority class to balance the dataset
C.Collect more data until the fraud rate increases
D.Train without any modifications; the model will naturally handle it
AnswerA

This addresses imbalance effectively.

Why this answer

Class weights or resampling techniques like SMOTE are standard for imbalanced datasets. Option A is correct. Option B (undersampling majority) can lose information.

Option C (collect more data) is impractical. Option D (no alterations) will bias the model.

Full explanation →
100
MCQhard

An ML team has set up automated retraining triggered by Cloud Monitoring alerts. When a feature drift alert fires, a Cloud Function publishes to Pub/Sub, which triggers a Vertex AI Pipeline. However, the retraining pipeline is failing because the training data is not updated. What is the most likely cause?

A.The Cloud Function does not have permission to start the pipeline
B.The Pub/Sub topic is incorrectly configured
C.The training data in the pipeline input is stale or not refreshed
D.The model endpoint is overloaded
AnswerC

Correct: Retraining requires fresh data; if the pipeline uses the same old data, it may fail or not address drift.

Why this answer

Cloud Monitoring alerts can trigger retraining, but the pipeline typically expects the most recent data. If the training data is not refreshed, the pipeline may fail or produce a stale model.

Full explanation →
101
MCQmedium

A data analyst wants to use Vision API to detect custom objects in manufacturing images, but the pre-trained API does not recognize their specific components. They have 1000 labeled images. Which path offers the fastest time-to-value with minimal coding?

A.Store images in BigQuery and use ML.PREDICT with a custom model
B.Use AutoML Vision for object detection
C.Use a Cloud Function to call the Vision API and post-process results
D.Train a custom object detection model using TensorFlow on Vertex AI
AnswerB

No-code training and deployment.

Why this answer

AutoML Vision for object detection is the fastest path because it requires no custom coding—users simply upload labeled images, and the platform automatically trains a model tailored to their custom components. This directly addresses the need to detect objects the pre-trained Vision API cannot recognize, while minimizing time-to-value compared to manual TensorFlow training or custom infrastructure setup.

Exam trap

Google Cloud often tests the misconception that any cloud function or API call can be adapted to custom objects via post-processing, but the pre-trained Vision API's fixed label set cannot be extended without retraining, making AutoML the only low-code solution that actually learns new object classes.

How to eliminate wrong answers

Option A is wrong because BigQuery ML.PREDICT is designed for structured data and tabular models, not for image-based object detection; storing images in BigQuery and using ML.PREDICT would require converting images to embeddings or using a pre-trained model, which does not solve the custom object recognition problem efficiently. Option C is wrong because calling the pre-trained Vision API via Cloud Function and post-processing results still relies on the same pre-trained model that cannot recognize the custom components, so it fails to address the core requirement. Option D is wrong because training a custom model using TensorFlow on Vertex AI requires significant coding, manual architecture design, and hyperparameter tuning, which is far slower and more complex than using AutoML Vision's no-code automated training pipeline.

Full explanation →
102
Multi-Selectmedium

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

Select 3 answers
A.Use spot VMs
B.Use MultiWorkerMirroredStrategy
C.Use TPUs instead of GPUs
D.Enable checkpointing and save to Cloud Storage
E.Use a single worker with multiple GPUs instead of multiple workers
AnswersA, D, E

Discounted instances.

Why this answer

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

Full explanation →
103
MCQhard

A machine learning pipeline in Vertex AI produces a dataset artifact, a trained model, and evaluation metrics. The team wants to query the lineage to find all downstream artifacts that depend on a particular dataset. Which Vertex AI service should they use?

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

Metadata stores lineage between artifacts and executions, enabling queries for upstream/downstream dependencies.

Why this answer

Vertex AI Metadata tracks artifacts, executions, and their lineage relationships. It supports lineage queries to find upstream and downstream dependencies.

Full explanation →
104
MCQeasy

An ML team wants to automatically track training runs, including hyperparameters and metrics, with minimal code changes. Which Vertex AI service should they use?

A.Vertex AI Prediction
B.Vertex AI Workbench
C.Vertex AI Metadata
D.Vertex AI Experiments with autologging
AnswerD

Autologging automatically records runs with minimal code.

Why this answer

Vertex AI Experiments with autologging captures parameters and metrics automatically when using the Vertex AI SDK or MLflow.

Full explanation →
105
MCQeasy

Refer to the exhibit. A team runs the command above and sees only two models. They know there is a model 'model-v3' created three days ago. What is the most likely reason it is not listed?

A.The model was created in a different region.
B.The model is in a different project.
C.The model is not deployed to an endpoint.
D.The model's display name contains a hyphen.
E.The model was created by a different user.
AnswerA

The --region flag filters models by location; missing models are likely in another region.

Why this answer

The `gcloud ai models list` command lists models within a specific region, as Vertex AI models are regional resources. If 'model-v3' was created in a different region, it would not appear in the output unless the `--region` flag is set to that region. This is the most likely reason the model is missing from the list.

Exam trap

Google Cloud often tests the regional scope of Vertex AI resources, trapping candidates who assume model listing is global or project-wide, when in fact it is region-specific and requires the correct `--region` flag.

How to eliminate wrong answers

Option B is wrong because the `gcloud ai models list` command operates within a single project (the current configured project or one specified with `--project`), but the question states the team sees only two models, implying they are in the correct project; a different project would require explicit project specification. Option C is wrong because model listing does not require deployment to an endpoint; Vertex AI lists all models in the project/region regardless of deployment status. Option D is wrong because hyphens in display names are allowed and do not affect listing; the command lists models by their resource name or display name without filtering on special characters.

Option E is wrong because model listing is not user-scoped; all models in the project/region are visible to any user with appropriate permissions, regardless of who created them.

Full explanation →
106
MCQhard

A team deployed a prototype classification model to Vertex AI Prediction. After a week, they notice the metrics shown in the exhibit. What is the most likely cause of the performance degradation and latency increase?

A.The prediction endpoint's autoscaling is too slow, causing requests to queue and time out.
B.The prediction requests are too large, exceeding the maximum request size limit for Vertex AI.
C.The training data does not represent the current production data distribution, causing the model to make incorrect predictions and requiring more computation.
D.The custom prediction container uses outdated libraries that are incompatible with Vertex AI's runtime.
AnswerC

Data distribution shift degrades accuracy and can increase latency if the model is uncertain.

Why this answer

The exhibit shows both accuracy degradation and increased latency. Option C is correct because when the production data distribution shifts away from the training data (data drift), the model makes more incorrect predictions, which can trigger additional computation (e.g., retries, fallback logic, or increased uncertainty estimation) and cause latency spikes. Vertex AI Prediction does not inherently add computation for wrong predictions, but the model's internal confidence thresholds or post-processing steps may consume extra resources when handling out-of-distribution inputs.

Exam trap

Google Cloud often tests the misconception that latency increase must be caused by infrastructure issues (autoscaling or request size) rather than model behavior, but the key clue is the simultaneous accuracy degradation, which points to data drift as the root cause.

How to eliminate wrong answers

Option A is wrong because autoscaling delays cause request queuing and timeouts, which would manifest as increased error rates and latency, but not as a degradation in prediction accuracy (metrics like precision/recall). Option B is wrong because exceeding the maximum request size limit (typically 1.5 MB for Vertex AI online prediction) would result in immediate 413 Payload Too Large errors, not a gradual performance degradation over a week. Option D is wrong because outdated libraries in a custom container would cause deployment failures or runtime errors (e.g., missing symbols, version conflicts), not a gradual accuracy drop; Vertex AI validates container compatibility at deployment time.

Full explanation →
107
MCQeasy

A marketing team wants to analyze customer reviews for sentiment without writing code. Which Google Cloud service should they use?

A.Cloud Dataflow
B.Vertex AI Workbench
C.BigQuery ML
D.Cloud Natural Language API
AnswerD

Correct: Pre-trained, no-code sentiment analysis.

Why this answer

The Cloud Natural Language API (option D) is the correct choice because it provides pre-trained models for sentiment analysis, entity recognition, and syntax analysis via a simple REST API, requiring no code beyond sending HTTP requests. This aligns perfectly with the requirement to analyze customer reviews for sentiment without writing code, as the API abstracts all ML complexity.

Exam trap

Google Cloud often tests the distinction between services that require coding (like Dataflow or Workbench) versus those that offer pre-built, no-code APIs (like Cloud Natural Language API), leading candidates to mistakenly choose BigQuery ML because it uses SQL, which they perceive as 'low-code' but still requires explicit query writing and model management.

How to eliminate wrong answers

Option A is wrong because Cloud Dataflow is a fully managed stream and batch data processing service based on Apache Beam, requiring users to write code (e.g., Java or Python) to define data pipelines, making it unsuitable for a no-code sentiment analysis task. Option B is wrong because Vertex AI Workbench is a Jupyter-based notebook environment for building and deploying custom ML models, requiring users to write code (e.g., Python) to train or use models, not a no-code solution. Option C is wrong because BigQuery ML allows users to create and execute ML models using SQL queries, but it still requires writing SQL statements and managing model creation, which is not a no-code API for direct sentiment analysis of text.

Full explanation →
108
MCQeasy

A company has developed a prototype fraud detection model using a small sample of transactions. The prototype runs on a single VM and uses a Random Forest classifier. They want to scale to the full dataset of 50 million transactions. The data is stored in BigQuery. The team wants to use Vertex AI for training. After moving the code to a custom training container and using Vertex AI Training with a single n1-standard-4 machine, the training job fails with an error: "Process terminated with exit code 1". The logs show: "java.lang.OutOfMemoryError: Java heap space". The model uses a scikit-learn RandomForest. Which course of action is most appropriate?

A.Use a distributed training strategy with multiple workers.
B.Increase the machine type to n1-highmem-8 to provide more memory.
C.Switch from Random Forest to a linear model to reduce memory usage.
D.Switch to a high-CPU machine type like n1-highcpu-16.
AnswerB

More memory alleviates the OOM error for in-memory Random Forest.

Why this answer

Option B because increasing memory (n1-highmem-8) directly addresses the Java heap space error. Random Forest memory usage scales with data size, so more memory is needed. Option A is not appropriate because scikit-learn does not natively support distributed training, and setting up distributed Random Forest is complex.

Option C is unnecessary; switching to a linear model may reduce performance. Option D is wrong because high-CPU machines have less memory per core, which does not help with memory issues.

Full explanation →
109
MCQmedium

Two teams are collaborating on a project and want to use a shared Feature Store in Vertex AI. They need to ensure that features are discoverable and that access is controlled. What is the best practice?

A.Export features to CSV files in Cloud Storage and share the bucket
B.Build a custom feature pipeline using Dataflow and store in Cloud SQL
C.Each team stores features in their own BigQuery table and shares the table
D.Use Vertex AI Feature Store and grant appropriate IAM roles to each team
AnswerD

Vertex AI Feature Store provides a unified repository with access control and discovery.

Why this answer

Vertex AI Feature Store provides a managed service for sharing features with access controls via IAM roles and enables feature discovery through the UI and API. Option A is wrong because CSV files in Cloud Storage lack feature store metadata, versioning, and online serving capabilities. Option B is wrong because building a custom pipeline with Dataflow and storing in Cloud SQL is not a managed feature store solution and does not provide the same discovery or access control features.

Option C is wrong because each team maintaining their own BigQuery table does not offer centralized feature discovery or unified access control; a Feature Store centralizes metadata and permissions.

Full explanation →
110
Drag & Dropmedium

Drag and drop the steps to deploy a trained TensorFlow model to Vertex AI Prediction in the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps
Order
1Step 1
2Step 2
3Step 3
4Step 4

Why this order

Export the model, upload to GCS, register as a model, deploy to endpoint, then test.

Full explanation →
111
MCQhard

A team has set up the IAM policy above on a Vertex AI project. Alice, a data scientist, reports that she cannot create a Vertex AI Training custom job using a pre-built container. Other data scientists in the group 'data-scientists@example.com' have the same issue. What is the most likely cause?

A.The 'roles/aiplatform.user' role does not grant the permission to create custom training jobs.
B.The Vertex AI Custom Code Service Agent service account is missing the 'roles/aiplatform.user' role.
C.Alice is not included in the 'data-scientists@example.com' group.
D.The service account 'vertex-ai@project.iam.gserviceaccount.com' does not have permission to access the training data.
AnswerA

Creating custom jobs requires 'aiplatform.customJobs.create', which is not in the aiplatform.user role.

Why this answer

The 'roles/aiplatform.user' role does not include the 'aiplatform.customJobs.create' permission needed to create custom training jobs. To create custom training jobs, users need the 'roles/aiplatform.customJobUser' role. The correct answer is A because Alice and her group only have the basic user role, which lacks the necessary permission.

Exam trap

Candidates often assume that 'roles/aiplatform.user' provides all necessary permissions for Vertex AI tasks, but it does not cover custom job creation. The exam tests the distinction between the general user role and specific roles like 'roles/aiplatform.customJobUser'.

How to eliminate wrong answers

Option B is wrong because the Vertex AI Custom Code Service Agent service account is used for custom code training, but the issue is about pre-built containers, not custom code, and the service account's role assignment is not the cause of the permission error for the data scientists. Option C is wrong because the problem states that other data scientists in the group have the same issue, implying Alice is likely in the group; if she were not, she would have a different error, but the group-wide issue points to a role/permission problem. Option D is wrong because the service account 'vertex-ai@project.iam.gserviceaccount.com' is not directly involved in creating custom jobs; it is used for Vertex AI's internal operations, and the error is about creating the job, not accessing training data.

Full explanation →
112
MCQmedium

An organization uses Vertex AI Pipelines and wants to track the lineage of datasets, models, and metrics across pipeline runs. They need to query upstream and downstream dependencies of an artifact. Which service should they use?

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

Vertex AI Metadata provides a metadata store and lineage queries for artifacts, executions, and contexts.

Why this answer

Vertex AI Metadata stores ML metadata and supports lineage queries to track the provenance of artifacts across pipeline executions.

Full explanation →
113
MCQeasy

A team wants to share a trained model with other teams within the organization. They need to provide access to the model artifact in Vertex AI Model Registry and ensure that only authorized teams can deploy the model. What should they do?

A.Grant the other teams access to the Cloud Storage bucket where the model is stored
B.Set the model to public in Vertex AI Model Registry
C.Use Cloud Key Management Service to encrypt the model and share the decryption key
D.Use IAM to grant the 'aiplatform.models.deploy' role to the other teams on the model resource
AnswerD

IAM roles provide fine-grained access control within Vertex AI.

Why this answer

Vertex AI Model Registry uses IAM to control access to model resources. By granting the 'aiplatform.models.deploy' role on the specific model resource, you ensure that only authorized teams can deploy the model, while other operations (like viewing or updating) remain restricted. This follows the principle of least privilege and avoids exposing the model artifact broadly.

Exam trap

Google Cloud often tests the misconception that sharing the storage bucket or encryption key is sufficient for controlled deployment, when in fact IAM roles on the model resource are required to enforce deployment authorization.

How to eliminate wrong answers

Option A is wrong because granting access to the Cloud Storage bucket where the model is stored would allow teams to download or modify the model artifact directly, bypassing Vertex AI's deployment controls and audit logging. Option B is wrong because setting the model to public in Vertex AI Model Registry would allow anyone in the world to deploy the model, violating security requirements. Option C is wrong because Cloud KMS encrypts data at rest but does not control access to the model resource; sharing the decryption key would not prevent unauthorized deployment, as the key only decrypts the artifact, not the deployment permission.

Full explanation →
114
MCQmedium

An ML engineer is building a pipeline that includes a step to run a BigQuery query and pass the results to the next step. They want to use a pre-built Google Cloud Pipeline Component for BigQuery. Which component should they use to execute a query and output the results to a destination table?

A.BigQueryExecuteQuery
B.BigQueryExportData
C.BigQueryQueryJobOp
D.BigqueryRunQuery
AnswerA

This component executes a SQL query and writes results to a destination table.

Why this answer

The correct component is BigQueryExecuteQuery because it is the pre-built Google Cloud Pipeline Component (from the `google-cloud-pipeline-components` package) specifically designed to run a BigQuery SQL query and write the results to a destination table. It returns a `DatasetArtifact` or `Table` artifact that can be passed to downstream pipeline steps, fulfilling the requirement of outputting results to a destination table.

Exam trap

The trap here is that candidates confuse the generic BigQuery client method `query()` or the legacy `BigQueryQueryJobOp` with the official pipeline component `BigQueryExecuteQuery`, which is the only one that properly integrates with Kubeflow Pipelines artifact passing and is the recommended approach in the PMLE exam domain.

How to eliminate wrong answers

Option B (BigQueryExportData) is wrong because it exports data from a BigQuery table to external storage (e.g., Cloud Storage, Drive) rather than executing a query and writing results to a destination table. Option C (BigQueryQueryJobOp) is wrong because it is a legacy component from the `kfp.gcp` module that uses the `google-cloud-bigquery` client directly but does not output a structured artifact for pipeline orchestration; it is deprecated in favor of `BigQueryExecuteQuery`. Option D (BigqueryRunQuery) is wrong because it is not a valid component name in the official Google Cloud Pipeline Components library; the correct casing and naming is `BigQueryExecuteQuery`.

Full explanation →
115
MCQhard

You are troubleshooting a failed Vertex AI AutoML training pipeline. The error log shows: 'ValueError: budget_milli_node_hours must be greater than 0'. What is the root cause?

A.The budget_milli_node_hours parameter is set to 0, which is below the minimum required value
B.The evaluate_model component expects the model artifact but the autopilot_train component does not output a model artifact
C.The location parameter 'us-central1' is not a valid region for AutoML
D.The threshold parameter is missing in the autopilot_train component
AnswerA

Must be at least 1000 (1 node hour).

Why this answer

In Vertex AI AutoML training, the `budget_milli_node_hours` parameter specifies the maximum compute time in milliseconds. Setting it to 0 means no compute time is allocated, which is below the minimum required value (typically 1 or higher depending on task type). This causes an immediate validation failure, preventing the training job from starting.

Options B, C, and D describe issues that are not the root cause given the correct answer.

Exam trap

Google Cloud often tests the misconception that a zero value for a resource allocation parameter is acceptable or defaults to a minimum, when in fact it causes an immediate validation failure.

How to eliminate wrong answers

Option B is wrong because the `autopilot_train` component in Vertex AI AutoML does output a model artifact; the failure is not due to a missing artifact but due to the zero budget parameter. Option C is wrong because `us-central1` is a valid region for AutoML in Vertex AI, and region validity is not the issue here. Option D is wrong because the `threshold` parameter is not a required parameter for the `autopilot_train` component; the failure is caused by the zero budget, not a missing threshold.

Full explanation →
116
MCQmedium

You are performing post-training quantisation of a trained TensorFlow model to INT8 for deployment on edge devices. Which technique should you use to minimise accuracy loss?

A.Float16 quantisation
B.Quantisation-aware training
C.Post-training integer quantisation with calibration
D.Post-training dynamic range quantisation
AnswerB

Trains the model to be robust to quantisation, minimising accuracy loss.

Why this answer

Quantisation-aware training (QAT) simulates quantisation during training, allowing the model to adapt, resulting in higher accuracy than post-training quantisation. Post-training quantisation is simpler but may lose accuracy.

Full explanation →
117
Multi-Selecthard

A retail company wants to implement a recommendation system using Recommendations AI. They need to generate personalized recommendations for users based on their browsing history and purchase behavior. Which THREE recommendation types are available in Recommendations AI?

Select 3 answers
A.trending-now
B.recommended-for-you
C.others-you-may-like
D.frequently-bought-together
E.most-popular
AnswersB, C, D

Why this answer

Recommendations AI offers five recommendation types: recommended-for-you (personalized), others-you-may-like (item similarity), frequently-bought-together (complementary), recently-viewed (session-based), and also-viewed. 'Most popular' is not a built-in type.

Full explanation →
118
MCQmedium

A company wants to implement continuous training for their ML model. The pipeline should be triggered when new training data arrives in Cloud Storage, and after training, the model should be automatically deployed to a staging endpoint if evaluation metrics pass a threshold. They also need to detect skew between training data and serving data. Which two services should they use for skew detection?

A.Cloud Monitoring and Cloud Logging
B.Cloud DLP and Cloud KMS
C.Vertex AI Model Monitoring and Vertex AI Pipelines
D.BigQuery and Dataflow
AnswerC

Correct: Vertex AI Model Monitoring detects skew, and pipelines orchestrate the process.

Why this answer

Vertex AI Model Monitoring provides built-in skew detection by comparing training data statistics with serving data statistics, alerting when distribution shifts exceed thresholds. Vertex AI Pipelines orchestrates the continuous training workflow, including triggering on new data arrival, model evaluation, and conditional deployment to a staging endpoint, making C the correct pair for both skew detection and pipeline automation.

Exam trap

Google often tests the distinction between general-purpose monitoring/logging services (Cloud Monitoring/Logging) and ML-specific monitoring (Vertex AI Model Monitoring), leading candidates to pick A because they think 'monitoring' means the same thing.

How to eliminate wrong answers

Option A is wrong because Cloud Monitoring and Cloud Logging are used for infrastructure and application monitoring (metrics, logs, alerts), not for statistical skew detection between training and serving data distributions. Option B is wrong because Cloud DLP (Data Loss Prevention) and Cloud KMS (Key Management Service) handle data security, masking, and encryption, not model monitoring or data skew analysis. Option D is wrong because BigQuery and Dataflow are data processing and analytics services; while they can compute statistics, they lack the specialized skew detection, alerting, and integration with Vertex AI endpoints that Vertex AI Model Monitoring provides natively.

Full explanation →
119
MCQhard

A company has a large-scale ML system that uses Vertex AI Pipelines to retrain models weekly. The pipeline includes a custom training job and a batch prediction step. After moving to production, they observe that batch prediction jobs often fail with 'Quota exceeded' errors. The project has sufficient CPU quota. What is the most likely cause?

A.The pipeline is exceeding the maximum number of concurrent pipeline runs.
B.The batch prediction job is requesting a specific accelerator type that has a separate quota limit.
C.The batch prediction job is using a machine type that is not available in the region.
D.The custom training job is consuming all available quota before the batch prediction job starts.
AnswerB

GPUs/TPUs have separate quotas; if exceeded, the job fails with quota exceeded.

Why this answer

The most likely cause is that the batch prediction job is requesting a specific accelerator type (e.g., GPU or TPU) that has a separate quota limit from CPU quota. In Vertex AI, accelerator quotas are distinct from general compute (CPU) quotas, and even if the project has sufficient CPU quota, the accelerator quota may be exhausted, causing 'Quota exceeded' errors.

Exam trap

Google Cloud often tests the misconception that all quota errors are related to CPU or memory, but the trap here is that accelerator types (GPUs/TPUs) have their own independent quota limits that are easily overlooked when CPU quota appears sufficient.

How to eliminate wrong answers

Option A is wrong because exceeding the maximum number of concurrent pipeline runs would result in pipeline submission failures or throttling, not batch prediction job failures with 'Quota exceeded' errors; Vertex AI Pipelines enforces concurrency limits separately. Option C is wrong because if a machine type is not available in the region, the error would be a resource availability error (e.g., 'Machine type not found'), not a quota exceeded error. Option D is wrong because the custom training job and batch prediction job run sequentially within the same pipeline; the training job completes before the batch prediction job starts, so it cannot consume quota during the batch prediction step.

Full explanation →
120
Multi-Selectmedium

A company wants to implement a centralized model registry for governance. Which two features should they use? (Choose two.)

Select 2 answers
A.Vertex AI Feature Store
B.Vertex AI Model Registry
C.Vertex AI Experiments
D.Model versioning and aliases
E.Vertex AI Metadata
AnswersB, D

Central registry for model versioning and governance.

Full explanation →
121
MCQeasy

An ML engineer is using Vertex AI Pipelines with Kubeflow Pipelines SDK (KFP) to orchestrate a training and deployment workflow. They want to reuse a custom component across multiple pipelines. The component is defined in a Python file 'preprocess.py' that includes a function decorated with @kfp.components.create_component_from_func. How should they package this component for reuse?

A.Import the preprocess module and call create_component_from_func on the function, then use the resulting component in pipeline definitions.
B.Save the component as a YAML file using kfp.components.ComponentStore and load it in other pipelines.
C.Compile the pipeline that uses the component into a JSON file and upload it to Vertex AI.
D.Build a custom container image with the function and use it as a base image in other pipelines.
AnswerA

This allows the component to be defined once and reused.

Why this answer

The recommended way to reuse a custom component defined via `@kfp.components.create_component_from_func` is to import the Python module containing the decorated function and call `create_component_from_func` on that function in each pipeline definition. This creates a reusable component object that can be used directly in the pipeline's `@dsl.pipeline` definition without additional packaging steps. The KFP SDK treats the function as the source of truth, and re-importing ensures the component logic is always current.

Exam trap

The trap here is that candidates may overthink the packaging step and assume a YAML file or container image is required for reuse, when the KFP SDK is designed to treat Python functions as first-class reusable components through simple module imports.

How to eliminate wrong answers

Option B is wrong because `kfp.components.ComponentStore` does not exist; components are stored as YAML using `kfp.components.ComponentStore.load_component_from_file` or `kfp.components.load_component_from_url`, but saving a component as YAML is not the standard method for reusing a `create_component_from_func` component—it is typically used for pre-built or container-based components. Option C is wrong because compiling a pipeline into JSON (or YAML) is for submitting the pipeline to Vertex AI, not for packaging a single component for reuse; the compiled artifact represents the entire pipeline, not an individual component. Option D is wrong because building a custom container image is unnecessary overhead for a lightweight Python function component; container images are used for components defined with `@kfp.components.create_component_from_func` only when the function requires non-standard dependencies, but the question does not indicate such a need, and the standard reuse method is direct import.

Full explanation →
122
MCQhard

You have a Vertex AI endpoint with two deployed models: a champion (v1) and a challenger (v2). You set the traffic split to 90% v1 and 10% v2. After a week, you observe that v2 has better business metrics. You want to shift all traffic to v2 gradually over 3 days to avoid any risk. What should you do?

A.Deploy v2 to a new endpoint and update your clients to use the new endpoint.
B.Use Vertex AI Experiments to compare v1 and v2, then redeploy v2 with 100% traffic.
C.Update the traffic split configuration on the endpoint multiple times over the 3 days to gradually increase v2's percentage.
D.Delete v1 from the endpoint so that all traffic automatically goes to v2.
AnswerC

This is the correct method for gradual traffic shifting.

Why this answer

Vertex AI endpoints support live traffic splitting between deployed models, allowing you to gradually shift traffic from v1 to v2 by updating the traffic split configuration multiple times over the 3-day period. This approach minimizes risk by enabling incremental rollouts and immediate rollback if issues arise, without requiring client-side changes or downtime.

Exam trap

The trap here is that candidates may assume deleting the old model or redeploying with 100% traffic is acceptable, but the question explicitly requires a gradual shift over 3 days to avoid risk, which only incremental traffic split updates can achieve.

How to eliminate wrong answers

Option A is wrong because deploying v2 to a new endpoint and updating clients introduces unnecessary complexity, potential downtime, and defeats the purpose of gradual traffic shifting; it also requires client-side changes, which is riskier and not aligned with the goal of avoiding risk. Option B is wrong because Vertex AI Experiments are used for offline model evaluation and comparison, not for live traffic management; redeploying v2 with 100% traffic would be an abrupt switch, not a gradual shift over 3 days. Option D is wrong because deleting v1 from the endpoint would immediately route 100% of traffic to v2, which is an abrupt change, not gradual, and violates the requirement to shift traffic gradually over 3 days to avoid risk.

Full explanation →
123
MCQeasy

A data scientist wants to automate the retraining of a model when new data arrives in Cloud Storage. Which Google Cloud service is most appropriate for orchestrating this workflow?

A.Cloud Run
B.Vertex AI Predictions
C.Cloud Scheduler
D.Cloud Composer
E.Cloud Functions
AnswerD

Cloud Composer can orchestrate complex workflows triggered by data events.

Why this answer

Cloud Composer (D) is the most appropriate service for orchestrating a retraining workflow because it is a fully managed workflow orchestration service built on Apache Airflow. It allows you to define a Directed Acyclic Graph (DAG) that triggers model retraining when new data arrives in Cloud Storage, handling dependencies, scheduling, and monitoring across multiple steps such as data validation, training, and deployment.

Exam trap

The trap here is that candidates often confuse event-triggered compute services (like Cloud Functions) with full workflow orchestration, failing to recognize that retraining pipelines require multi-step dependency management, retries, and monitoring that only a dedicated orchestrator like Cloud Composer provides.

How to eliminate wrong answers

Option A (Cloud Run) is wrong because it is a serverless compute platform for running stateless containers, not a workflow orchestrator; it lacks native scheduling and dependency management for multi-step pipelines. Option B (Vertex AI Predictions) is wrong because it is a service for deploying models to serve predictions, not for orchestrating the retraining workflow triggered by new data. Option C (Cloud Scheduler) is wrong because it is a cron job service that triggers single actions at fixed times, not a workflow orchestrator that can handle event-driven triggers, conditional logic, and multi-step dependencies.

Option E (Cloud Functions) is wrong because it is a lightweight, event-driven compute service for single-purpose functions; while it can be triggered by Cloud Storage events, it cannot orchestrate complex multi-step pipelines with retries, branching, or monitoring.

Full explanation →
124
Multi-Selectmedium

An engineer wants to set up request/response logging for a Vertex AI Endpoint to analyze prediction behavior. Which TWO resources must be configured? (Choose 2)

Select 2 answers
A.Vertex AI Model Monitoring enabled
B.A Cloud Pub/Sub topic for streaming logs
C.A Cloud Logging log sink that routes endpoint logs to BigQuery
D.A BigQuery dataset to store the log entries
E.Cloud Functions to transform logs
AnswersC, D

Log sink is required to export logs to BigQuery.

Why this answer

Request/response logging requires a BigQuery table as the sink destination and the log entry must include the prediction input/output.

Full explanation →
125
MCQhard

A company uses Vertex AI Feature Store with an online store for low-latency serving. They observe high latency during peak hours. The feature values are small (< 1 KB each) and the workload is read-heavy. Which change would most effectively reduce latency?

A.Enable caching on the client side
B.Switch from Bigtable online store to Optimized online store
C.Use a larger machine type for Bigtable
D.Increase the number of Bigtable nodes
AnswerB

Optimized store provides lower latency for read-heavy patterns.

Why this answer

Switching from Bigtable online store to Optimized online store is recommended for read-heavy workloads with small feature values, offering lower latency at high QPS.

Full explanation →
126
Multi-Selecthard

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

Select 3 answers
A.Using Vertex AI Vizier to optimize the model parallelism strategy
B.Enabling Vertex AI AutoML to automatically distribute the model
C.Implementing pipeline parallelism manually in the training script using torch.distributed.pipeline.sync.Pipe
D.A custom container with the distributed framework (e.g., PyTorch DDP) installed
E.Setting the --worker-machine-count flag when submitting the job
AnswersC, D, E

Manual implementation of pipeline parallelism is required as Vertex AI does not provide built-in model parallelism.

Why this answer

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

Exam trap

This question tests the misconception that Vertex AI automatically handles model parallelism (e.g., via AutoML or Vizier), when in reality the user must manually implement it in the training script using frameworks like PyTorch or TensorFlow.

Full explanation →
127
MCQmedium

Refer to the exhibit. A team leader applies this IAM policy on a Vertex AI model resource. What does the condition accomplish?

A.Allows the data scientist to access model evaluations only
B.Limits access to models whose resource name starts with 'dev-'
C.Limits access to models owned by the data scientist
D.Limits access to models only in the us-central1 region
E.Limits access to models created after a certain date
AnswerB

The condition 'resource.name.startsWith' matches only models with the 'dev-' prefix.

Why this answer

The condition in the IAM policy uses the `resource.name.startsWith('dev-')` condition expression, which restricts access to Vertex AI model resources whose resource name begins with the prefix 'dev-'. This is a common pattern for environment-based access control, allowing the data scientist to only interact with models designated for development.

Exam trap

Google Cloud often tests the distinction between resource name prefix matching and other common IAM conditions like resource labels, resource location, or creation timestamp, leading candidates to confuse a simple string prefix check with more complex attribute-based conditions.

How to eliminate wrong answers

Option A is wrong because the condition does not restrict access to model evaluations; it filters based on the resource name prefix, not the resource type or sub-resource. Option C is wrong because IAM conditions cannot dynamically check resource ownership; they operate on resource attributes like name, not on who created the resource. Option D is wrong because the condition does not reference any region attribute; region-based filtering would require a condition on `resource.location` or similar.

Option E is wrong because the condition does not involve any date or timestamp comparison; it only checks the string prefix of the resource name.

Full explanation →
128
MCQhard

A company has an existing TensorFlow model for fraud detection that they want to use for predictions in BigQuery. They want to call the model from SQL queries without moving data out of BigQuery. How should they deploy the model?

A.Import the TensorFlow model directly into BigQuery ML
B.Deploy the model to Vertex AI Prediction and use a remote model in BigQuery ML
C.Export BigQuery data to Cloud Storage and use AI Platform Prediction
D.Use AutoML Tables to retrain the model in BigQuery ML
AnswerA

Why this answer

BigQuery ML (BQML) natively supports importing TensorFlow models directly, allowing you to use them for predictions via SQL without moving data out of BigQuery. This is the simplest and most efficient approach because it eliminates the need for external services or data export, leveraging BQML's built-in `CREATE MODEL` statement with the `OPTIONS(model_type = 'TENSORFLOW')` clause.

Exam trap

The trap here is that candidates often overcomplicate the solution by choosing Vertex AI or AI Platform, not realizing that BigQuery ML has native TensorFlow support, which is the most direct and low-code way to meet the requirement of keeping data in BigQuery.

How to eliminate wrong answers

Option B is wrong because deploying to Vertex AI Prediction and using a remote model adds unnecessary complexity and latency; while it works, it requires setting up a remote model and a connection, which is not the simplest or most direct method when BQML directly supports TensorFlow imports. Option C is wrong because exporting BigQuery data to Cloud Storage and using AI Platform Prediction moves data out of BigQuery, violating the requirement to keep data in BigQuery and adding extra steps and cost. Option D is wrong because AutoML Tables retrains the model from scratch, which does not reuse the existing TensorFlow model and may produce different results, whereas the requirement is to use the existing model as-is.

Full explanation →
129
MCQmedium

A data science team deploys a PyTorch model using Vertex AI Prediction. The model requires GPU for inference, but they notice high costs and underutilized GPUs during off-peak hours. What is the most cost-effective solution?

A.Move the model to Cloud Functions
B.Use a GPU instance with a fixed number of replicas
C.Use a GPU instance with min replicas=0 and autoscaling
D.Switch to a CPU-only machine type
AnswerC

Scales down to zero when unused, saving costs.

Why this answer

Setting min replicas to 0 allows Vertex AI Prediction to scale down to zero instances during off-peak hours, eliminating GPU costs when no requests are being served. Combined with autoscaling, the deployment will spin up GPU-backed instances on demand only when traffic arrives, directly addressing the underutilization issue while maintaining low latency for inference requests.

Exam trap

Google Cloud often tests the misconception that autoscaling alone reduces costs, but the trap here is that without setting min replicas to 0, you still pay for idle GPU instances during off-peak hours, which is the exact problem described in the question.

How to eliminate wrong answers

Option A is wrong because Cloud Functions does not support GPU acceleration; it runs in a serverless environment limited to CPU-only execution, making it unsuitable for GPU-required inference. Option B is wrong because a fixed number of replicas (even with autoscaling) keeps at least one GPU instance running at all times, failing to eliminate costs during zero-traffic periods; min replicas must be 0 to achieve true cost savings. Option D is wrong because the model explicitly requires GPU for inference, and switching to CPU-only would break inference performance or make it infeasible due to model architecture or latency requirements.

Full explanation →
130
MCQhard

A machine learning engineer notices that a model served on Vertex AI Endpoints returns predictions that are consistently 20% slower during the first request after idle (cold start). They are using automatic scaling with min replicas=1. What is the most likely cause and best solution?

A.Vertex AI endpoint warm-up time; set min replicas to 2 to always keep a warm instance
B.Model loading time is high; enable health checks to warm the instance
C.Network latency; deploy to a different region
D.Container initialization delay; use a smaller container image
AnswerA

Increasing min replicas ensures at least one warm instance is always available, reducing cold start latency.

Why this answer

With min replicas=1, a single instance is always running, but it may become idle and require a warm-up period to reload the model into memory, causing the first request to be slower. Setting min replicas to 2 ensures at least one instance remains fully warm to handle requests immediately, reducing cold start latency. Option B is incorrect because health checks measure readiness but do not actively warm the instance; they only prevent traffic until the instance is ready, which doesn't address the delay.

Option C is incorrect because network latency would affect all requests consistently, not just the first after idle. Option D is incorrect: a smaller container image reduces initial load time but does not prevent the warm-up delay after idle, and the main issue is the model or endpoint warm-up, not container size.

Full explanation →
131
Multi-Selecthard

A company deploys a model to Vertex AI Endpoint with autoscaling enabled. During a traffic spike, they observe high tail latency (99th percentile > 2s). Which TWO factors are most likely contributing to this latency?

Select 2 answers
A.The machine type is underpowered for the model.
B.The autoscaling target_cpu_utilization is set too low (e.g., 0.3).
C.The endpoint has too many traffic splits configured.
D.The min_replica_count is set too low, causing cold starts.
E.The model file is very large (e.g., 2GB), increasing model loading time.
AnswersD, E

Low min replicas lead to cold start delays during spikes.

Why this answer

Options D and E are correct. Option D: if min_replica_count is set too low, during a traffic spike new replicas must be created, and loading the model causes cold start latency, increasing tail latency. Option E: a large model file (e.g., 2GB) increases the time for new replicas to load the model, exacerbating cold start delays.

Option A (underpowered machine) would cause higher average latency, not specifically tail latency. Option B (target_cpu_utilization set too low) would cause scaling to occur earlier, potentially reducing tail latency, not contributing to it. Option C (too many traffic splits) is unrelated to tail latency.

Full explanation →
132
MCQmedium

You need to run batch predictions on 10 TB of text data stored in BigQuery using a custom container model hosted in Vertex AI. What is the most cost-effective and simple approach?

A.Use Vertex AI batch prediction with BigQuery source and sink.
B.Use Cloud Run jobs to read from BigQuery and write results back.
C.Export BigQuery data to GCS, then run a Dataflow pipeline to call the model's online prediction endpoint for each row.
D.Use Cloud Dataproc to spin up a Spark cluster and run the model inference in parallel.
AnswerA

Correct. Vertex AI batch prediction natively supports BigQuery as both source and sink.

Why this answer

Vertex AI batch prediction natively supports BigQuery as both source and sink, allowing you to run predictions on 10 TB of text data without any data movement or intermediate storage. This is the most cost-effective and simple approach because it eliminates the need for exporting data, managing infrastructure, or calling online endpoints, and it leverages Vertex AI's optimized batch inference infrastructure that scales automatically.

Exam trap

The exam often tests the misconception that you must export data from BigQuery to GCS before running batch predictions, when in fact Vertex AI batch prediction can directly read from and write to BigQuery, making the export step unnecessary and cost-inefficient.

How to eliminate wrong answers

Option B is wrong because Cloud Run jobs have a maximum request timeout of 60 minutes and are not designed for processing 10 TB of data efficiently; they would require complex batching and retry logic, and would incur higher costs due to per-request pricing and lack of native BigQuery integration. Option C is wrong because exporting data to GCS and then using Dataflow to call the online prediction endpoint for each row introduces unnecessary data movement, storage costs, and network latency; online endpoints are designed for low-latency single requests, not high-throughput batch processing, and this approach would be both slower and more expensive. Option D is wrong because Cloud Dataproc requires you to manage a Spark cluster, handle autoscaling, and write custom inference code, which adds operational complexity and cost for a task that Vertex AI batch prediction can handle natively with no infrastructure management.

Full explanation →
133
MCQmedium

A financial services company uses Vertex AI AutoML Tables to build a credit risk model. The dataset contains 500,000 rows and 50 features, including loan amount, credit score, debt-to-income ratio, and employment length. The target variable is binary: 'default' (1) or 'no default' (0). The data is highly imbalanced, with only 2% defaults. The data scientist trains a model with AutoML Tables using default settings. The evaluation metrics show an AUC of 0.85, but the confusion matrix reveals that the model predicts 'no default' for almost all cases, missing most defaults. The data scientist needs to improve the model's ability to identify defaults without significantly increasing false positives. They have limited time and cannot write custom code. What should they do?

A.Manually split the data into a stratified train/test set to ensure the same proportion of defaults in each.
B.Train multiple models with different algorithms (e.g., XGBoost, Random Forest) and blend them using a custom script.
C.Enable 'Enable weighted evaluation' and set the optimization objective to 'Maximize recall at a specific recall@P%' with a target precision of 0.5.
D.Under-sample the majority class to create a balanced dataset and retrain.
AnswerC

This is correct because it uses AutoML Tables' built-in weighted evaluation and custom optimization objective to focus on recall for the minority class, without needing custom code.

Why this answer

AutoML Tables allows you to set a custom optimization objective to handle class imbalance without custom code. By enabling weighted evaluation and setting the objective to 'Maximize recall at a specific recall@P%' with a target precision of 0.5, the model will be tuned to prioritize identifying defaults (recall) while maintaining a specified precision level, directly addressing the need to catch more defaults without a massive increase in false positives.

Exam trap

Google Cloud often tests the misconception that manual data splitting or resampling is necessary for imbalanced data in AutoML, when in fact AutoML Tables provides built-in optimization objectives and weighted evaluation to handle imbalance without data manipulation.

How to eliminate wrong answers

Option A is wrong because AutoML Tables already performs stratified splitting by default; manually splitting does not change the model's training behavior or address the imbalance issue. Option B is wrong because it requires writing custom code (blending scripts), which violates the constraint of 'cannot write custom code' and is not a native AutoML Tables feature. Option D is wrong because under-sampling the majority class reduces the dataset size and discards valuable data, which can degrade model performance and is not recommended with AutoML Tables' built-in imbalance handling capabilities.

Full explanation →
134
MCQmedium

You need to perform batch predictions on 10 TB of data stored in BigQuery using Vertex AI. The model requires some preprocessing that cannot be expressed in SQL. What is the most scalable approach?

A.Use a Cloud Function to preprocess each row and write to a new BigQuery table, then run batch prediction.
B.Use Dataflow to read from BigQuery, perform preprocessing, write results to GCS, then run Vertex AI batch prediction job with GCS source.
C.Use Vertex AI batch prediction with BigQuery source and include preprocessing logic in the model container.
D.Export BigQuery data to CSV, run a local Python script for preprocessing, then upload to GCS and start a batch prediction job.
AnswerB

Dataflow handles large-scale preprocessing and the pipeline integrates well with Vertex AI.

Why this answer

Dataflow (Apache Beam) provides a fully managed, auto-scaling, serverless execution environment that can read from BigQuery, apply arbitrary Python/Java preprocessing logic (e.g., feature engineering, normalization) that cannot be expressed in SQL, and write the preprocessed results to Cloud Storage (GCS). Vertex AI batch prediction can then read from GCS as input, making this the most scalable approach for 10 TB of data without requiring custom model container changes or manual data movement.

Exam trap

A common misconception is that Cloud Functions can handle large-scale batch processing, but the trap here is that Cloud Functions are designed for event-driven, short-lived tasks, not for processing terabytes of data in a batch pipeline. Dataflow is the appropriate Google Cloud service for this scenario.

How to eliminate wrong answers

Option A is wrong because Cloud Functions have a 9-minute timeout and limited memory (up to 8 GB), making them unsuitable for processing 10 TB of data row-by-row; they would require an impractical number of invocations and lack built-in parallelization for large-scale batch workloads. Option C is wrong because Vertex AI batch prediction with a BigQuery source does not support preprocessing logic inside the model container — the container receives raw data and must handle all transformations itself, which couples preprocessing to the model and violates separation of concerns; also, BigQuery source does not allow custom preprocessing steps before inference. Option D is wrong because exporting 10 TB of data to CSV, running a local Python script (single machine, no distributed processing), then uploading to GCS is not scalable — it creates a bottleneck at the local script, requires significant network transfer, and does not leverage managed services for parallel processing.

Full explanation →
135
MCQmedium

A company has deployed a model that predicts customer churn. The model's performance, as measured by AUC, has been declining over the past month. The team suspects data drift. They have enabled Vertex AI Model Monitoring, but no alerts have been triggered. What is a possible reason for the lack of alerts?

A.The monitoring is only sampling 10% of the serving data
B.The drift detection threshold is set too low
C.The model is being retrained daily
D.The drift detection focuses on categorical features only
AnswerA

Low sampling rates mean that Model Monitoring only examines a small fraction of predictions, potentially missing drift if it is not uniformly distributed.

Why this answer

If the sampling rate is low (e.g., 10% of serving data), Model Monitoring may not capture enough data to detect drift, leading to no alerts even if drift exists. A low threshold would create more alerts, not fewer. Daily retraining might correct drift, but would still likely trigger alerts if drift occurred between retraining runs.

Restricting to categorical features only would miss continuous feature drift, but that would still trigger alerts for categorical features.

Full explanation →
136
MCQhard

An ML engineer is training a very large PyTorch model on Vertex AI using a TPU v3 pod. The training is slower than expected, and the TPU utilization is low. What is the most likely cause?

A.The data pipeline is a bottleneck; the TPU is waiting for data.
B.The learning rate schedule is too aggressive.
C.The model is using a single TensorFlow operation not supported by TPU.
D.The batch size is too large for the TPU memory.
AnswerA

TPUs are fast; insufficient data throughput leads to idle time.

Why this answer

The most likely cause of low TPU utilization is a data pipeline bottleneck, where the TPU spends a significant amount of time idle waiting for the next batch of data to be loaded and preprocessed. TPU v3 pods are designed for high-throughput matrix operations and can process data far faster than a typical CPU-based data loader can supply it, especially if the data pipeline uses inefficient I/O, lacks prefetching, or has insufficient workers. This mismatch starves the TPU, leading to low utilization and slower training.

Exam trap

Google often tests the misconception that low utilization is caused by model architecture or hyperparameter issues, when in reality the most common bottleneck in distributed TPU training is the data pipeline, not the compute or memory limits.

How to eliminate wrong answers

Option B is wrong because an aggressive learning rate schedule may cause training instability or divergence, but it does not directly cause low TPU utilization; utilization is a measure of hardware activity, not training convergence. Option C is wrong because the question explicitly states the model is a PyTorch model, and while PyTorch has limited TPU support compared to TensorFlow, the issue is not a single unsupported operation—such an operation would typically raise an error or fall back to CPU, not cause low utilization across the entire pod. Option D is wrong because a batch size that is too large for TPU memory would cause an out-of-memory (OOM) error, not low utilization; the TPU would fail to allocate the batch, not run slowly.

Full explanation →
137
Multi-Selecthard

A team is deploying a model on Vertex AI Prediction. Which THREE configuration settings have a direct impact on both latency and cost? (Choose THREE.)

Select 3 answers
A.Size of training dataset
B.Minimum and maximum number of nodes (autoscaling)
C.Machine type (e.g., n1-standard-2)
D.Model architecture (e.g., number of layers)
E.Number of replicas in the endpoint
AnswersB, C, E

More nodes lower latency but increase cost.

Why this answer

The minimum and maximum number of nodes in autoscaling directly control how many compute instances are provisioned to handle prediction requests. A higher minimum node count increases baseline cost and reduces cold-start latency, while a lower maximum can cause queuing and higher latency under load, directly impacting both metrics.

Exam trap

Google Cloud often tests the distinction between model-level properties (architecture, training data) and deployment-level configuration settings (machine type, replicas, autoscaling) to see if candidates confuse model development with serving infrastructure.

Full explanation →
138
MCQeasy

A team wants to use Vertex AI Workbench for collaborative notebook development. They need a persistent environment that can be stopped and restarted without losing installed packages and data. Which instance type should they choose?

A.User-managed notebooks
B.Managed notebooks
C.Colab Enterprise notebooks
D.Vertex AI Pipelines
AnswerA

User-managed notebooks are persistent and retain packages and data across stops/starts.

Why this answer

User-managed notebooks are persistent and retain customizations even when stopped, while managed notebooks are not persistent and lose customizations after stop.

Full explanation →
139
MCQeasy

An ML engineer needs to monitor the online prediction latency of a Vertex AI Endpoint. Which metrics should they look at in Cloud Monitoring?

A.p50, p95, p99 latency
B.Request count and error rate
C.Skew and drift scores
D.CPU/GPU utilization
AnswerA

Correct: These percentiles are standard for monitoring prediction latency.

Why this answer

Cloud Monitoring provides latency metrics for Vertex AI Endpoints, including p50, p95, and p99 latency, which are key for understanding performance.

Full explanation →
140
Multi-Selecthard

You are monitoring a production model that is experiencing gradual decay in AUC. Which THREE metrics should you set up alerts for to diagnose the root cause? (Choose three.)

Select 3 answers
A.Concept drift score measured by comparing predicted vs actual outcomes.
B.Training-serving skew for categorical features with high importance.
C.Average prediction latency over the past hour.
D.Feature drift score for key numerical features.
E.Model staleness (days since last retraining).
AnswersA, B, D

Detects changes in relationship between features and labels.

Why this answer

Concept drift directly measures the degradation of model performance by comparing predicted probabilities against actual outcomes over time. A gradual AUC decay indicates that the relationship between features and the target is shifting, and tracking concept drift via metrics like the PSI or distribution of residuals helps isolate whether the model's predictive power is eroding due to changing data patterns.

Exam trap

Google Cloud often tests the distinction between metrics that indicate a symptom (e.g., latency, staleness) versus metrics that directly measure the cause of performance decay (drift scores), leading candidates to select operational metrics instead of diagnostic ones.

Full explanation →
141
Multi-Selecthard

A company wants to use Document AI to process a large volume of invoices. They need to extract line items and also have a human review the extracted data for accuracy. Which THREE features should they use? (Choose 3)

Select 3 answers
A.Online Processing
B.Custom Extractor
C.Invoice Parser Processor
D.Human-in-the-Loop (HITL)
E.Batch Processing
AnswersC, D, E

Why this answer

The Invoice Parser Processor (C) is a specialized Document AI processor designed to extract structured data from invoices, including line items, which directly meets the requirement for extracting line items from a large volume of invoices. It is pre-trained on invoice layouts and can handle complex table structures, making it the correct choice for this task.

Exam trap

Google often tests the distinction between pre-built processors and custom extractors, where candidates mistakenly choose Custom Extractor (B) thinking they need a tailored solution, even though a pre-built Invoice Parser Processor (C) is available and more appropriate for standard invoice extraction.

Full explanation →
142
MCQeasy

A machine learning team wants to share features across multiple models to reduce training-serving skew and ensure consistency. Which Vertex AI service should they use?

A.Vertex AI Workbench
B.Vertex AI Model Registry
C.Vertex AI Feature Store
D.Vertex AI Experiments
AnswerC

Feature Store is designed for sharing and serving features consistently across training and serving.

Why this answer

Vertex AI Feature Store centralizes feature storage, ensuring the same features are used for training and serving, reducing training-serving skew.

Full explanation →
143
Multi-Selectmedium

A data science team has trained a custom model using Vertex AI and wants to deploy it for online predictions with low latency. Which TWO actions should they take to optimize performance?

Select 2 answers
A.Use Vertex AI Endpoints with traffic splitting for canary deployments.
B.Enable autoscaling with a large min replicas count to handle bursts.
C.Optimize the model by quantizing to FP16.
D.Use a custom prediction routine with pre-processing inside the container.
E.Use a machine type with GPU for inference.
AnswersC, D

Quantization reduces model size and inference latency, often with minimal accuracy loss.

Why this answer

Quantizing the model to FP16 reduces its memory footprint and computational requirements, directly lowering inference latency on compatible hardware (e.g., NVIDIA GPUs with Tensor Cores). This optimization is especially effective for online predictions where response time is critical, as it accelerates matrix operations without significantly sacrificing model accuracy.

Exam trap

Google Cloud often tests the misconception that scaling infrastructure (e.g., autoscaling or GPU selection) is the primary way to optimize latency, when in fact model-level changes (quantization) and architectural changes (custom routines) are more direct and cost-effective.

Full explanation →
144
Multi-Selectmedium

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

Select 2 answers
A.Use a larger machine type to reduce training time
B.Increase the number of parallel trials in hyperparameter tuning
C.Set the worker_pool_specs to use spot VMs by setting spot=True
D.Set the max_retry_count in the worker pool spec to a value greater than 0
E.Implement checkpointing in the training code to save model state periodically to Cloud Storage
AnswersD, E

Vertex AI will retry the job if preempted up to max_retry_count times.

Why this answer

To handle spot VM preemptions, the training job must be restartable. Using checkpoints allows the job to resume from the last saved state. Vertex AI automatically retries on preemption if the job is restartable (managed by the service).

Setting max_retry_count in the worker pool spec allows Vertex AI to automatically restart the job after preemption. Also, reducing machine type or increasing parallel trials are not direct solutions.

Full explanation →
145
MCQmedium

A machine learning engineer wants to monitor the fairness of a credit approval model across demographic subgroups. They have ground truth labels in BigQuery. Which approach should they use to evaluate performance disparities?

A.Use Vertex AI Model Evaluation with sliced evaluation in BigQuery
B.Use Vertex AI Explainability to compute feature attributions per subgroup
C.Use Cloud Monitoring custom metrics to track predictions per subgroup
D.Use Vertex AI Model Monitoring to detect skew in demographic features
AnswerA

Correct: Sliced evaluation computes metrics per subgroup to identify disparities.

Why this answer

Vertex AI Model Evaluation supports sliced evaluation, allowing comparison of metrics (like accuracy, precision) across subgroups defined by features like age, gender, etc.

Full explanation →
146
MCQmedium

Refer to the exhibit. An ML engineer in the team needs to deploy the model to an endpoint. The engineer is assigned the 'roles/aiplatform.user' role at the project level but still cannot deploy. What is the most likely reason?

A.The service account 'sa-training' is using all the model's quota.
B.Alice does not have any IAM role on the project.
C.Alice needs to be granted the 'roles/aiplatform.admin' role at the project level.
D.The model's resource-level IAM policy only grants the 'roles/aiplatform.user' role, which does not include deploy permission.
AnswerD

The resource policy overrides project-level roles and lacks deploy.

Why this answer

The 'roles/aiplatform.user' role at the project level grants permissions to use AI Platform resources, but it does not include the 'aiplatform.models.deploy' permission required to deploy a model to an endpoint. Model deployment is controlled by resource-level IAM policies, and if the model's resource-level policy only grants 'roles/aiplatform.user', the deploy action is denied. The correct role for deployment is 'roles/aiplatform.admin' or a custom role with the deploy permission.

Exam trap

Google Cloud often tests the distinction between project-level and resource-level IAM policies, where candidates assume that a project-level role automatically grants all permissions on child resources, ignoring that resource-level policies can be more restrictive.

How to eliminate wrong answers

Option A is wrong because quota usage by a service account does not affect IAM permissions; the error is about authorization, not resource limits. Option B is wrong because the question states the engineer is assigned 'roles/aiplatform.user' at the project level, so Alice does have an IAM role. Option C is wrong because while 'roles/aiplatform.admin' would grant deploy permission, the most likely reason for the failure is the model's resource-level IAM policy restricting deployment, not the project-level role.

Full explanation →
147
MCQeasy

A team is using Cloud Composer to orchestrate ML workflows. They want to allow multiple data scientists to contribute DAGs without interfering with each other. What is the recommended approach?

A.Give each data scientist write access to the DAGs folder in Cloud Storage
B.Use a complex naming convention for DAG files to avoid overwriting
C.Store DAGs in a source control repository and use CI/CD to deploy to Cloud Composer
D.Create a separate Cloud Composer environment for each data scientist
AnswerC

Version control and CI/CD provide collaboration, testing, and safe deployment.

Why this answer

Cloud Composer (based on Apache Airflow) recommends managing DAGs via source control and CI/CD pipelines to ensure version control, code review, and consistent deployment. This prevents conflicts when multiple data scientists contribute, as each change is tracked and tested before being synced to the DAGs folder in Cloud Storage, avoiding overwrites or broken workflows.

Exam trap

The trap here is that candidates may assume direct write access or naming conventions are sufficient for collaboration, but the Google Cloud recommended approach emphasizes source control and CI/CD to enforce code quality and prevent deployment conflicts.

How to eliminate wrong answers

Option A is wrong because giving each data scientist direct write access to the DAGs folder in Cloud Storage bypasses version control and can lead to accidental overwrites, conflicts, or deployment of untested code, breaking production workflows. Option B is wrong because a complex naming convention does not prevent race conditions or overwrites when multiple data scientists upload files simultaneously; it only reduces the probability of name collisions but does not address the core need for controlled, auditable deployments. Option D is wrong because creating a separate Cloud Composer environment for each data scientist is cost-prohibitive, inefficient, and defeats the purpose of shared orchestration; it also introduces overhead in managing multiple environments and does not solve the collaboration problem at scale.

Full explanation →
148
Multi-Selectmedium

A media company uses a custom Python script on a Compute Engine VM to run batch predictions with a large ML model. The script loads the model from Cloud Storage, processes records from a Pub/Sub pull subscription, and writes results to BigQuery. Predictions are taking too long and the VM often runs out of memory. Which two changes should the company implement to improve performance and scalability? (Choose TWO)

Select 2 answers
A.Deploy the model on Vertex AI Prediction for batch prediction
B.Change Pub/Sub to a push subscription that sends messages to a load-balanced group of VMs
C.Use Dataflow to read from Pub/Sub, run predictions using the model, and write to BigQuery
D.Switch to a larger VM with more memory
E.Store results in Cloud SQL instead of BigQuery
AnswersB, C

Push subscriptions with load balancing allow horizontal scaling across multiple VMs.

Why this answer

Switching to a push subscription with a load-balanced group of VMs distributes the message processing load across multiple instances, preventing any single VM from being overwhelmed. This directly addresses the memory exhaustion issue by parallelizing the work and allowing horizontal scaling.

Exam trap

Google Cloud often tests the distinction between vertical scaling (larger VM) and horizontal scaling (load-balanced VMs or Dataflow), where candidates mistakenly choose a larger VM thinking it solves memory issues without recognizing the scalability bottleneck.

Full explanation →
149
Drag & Dropmedium

Drag and drop the steps to set up a distributed training job on Vertex AI using a custom container in the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps
Order
1Step 1
2Step 2
3Step 3
4Step 4

Why this order

The correct sequence for setting up a distributed training job on Vertex AI using a custom container is to first prepare the training code and Dockerfile, then build and push the container image to a registry, then configure the job with the image URI and distributed settings, and finally submit the job. This order ensures that all dependencies are met at each step.

Full explanation →
150
MCQhard

A company uses a custom container on Vertex AI Prediction. They want to send custom metrics from their prediction container to Cloud Monitoring. Which method should they use?

A.OpenCensus or OpenTelemetry SDK
B.Vertex AI built-in metrics
C.Stackdriver Monitoring agent installed in the container
D.Cloud Logging log-based metrics
AnswerA

Vertex AI Prediction integrates with OpenTelemetry for custom metrics.

Why this answer

OpenCensus and OpenTelemetry are the recommended open-source frameworks for exporting custom metrics from custom containers on Vertex AI Prediction to Cloud Monitoring. They provide a standardized way to instrument your application code, collect metrics, and send them directly to Cloud Monitoring via the Cloud Monitoring API, without requiring additional agents or log-based workarounds.

Exam trap

The trap here is that candidates often confuse built-in Vertex AI metrics (which are automatic but limited) with the need for custom metrics, or they incorrectly assume that log-based metrics are the simplest path, when in fact OpenCensus/OpenTelemetry are the direct and recommended method for custom containers.

How to eliminate wrong answers

Option B is wrong because Vertex AI built-in metrics only cover default infrastructure metrics (e.g., CPU, memory, request latency) and cannot capture custom application-level metrics defined by the user. Option C is wrong because the Stackdriver Monitoring agent (now the Ops Agent) is designed for VM-based environments and is not intended to be installed inside a container; it would add unnecessary overhead and is not the recommended pattern for custom containers on Vertex AI. Option D is wrong because Cloud Logging log-based metrics require you to write metrics as structured log entries and then define metric filters, which is an indirect, higher-latency approach compared to directly exporting metrics via OpenCensus/OpenTelemetry, and it is not the standard method for custom containers in Vertex AI Prediction.

Full explanation →
Page 1

Page 2 of 14

Page 3

All pages

1234567891011121314

Practice PMLE by domain

Target a specific domain to shore up weak areas.

Automating and Orchestrating ML PipelinesCollaborating Within and Across Teams to Manage Data and ModelsServing and Scaling ModelsMonitoring ML SolutionsArchitecting Low-Code ML SolutionsScaling Prototypes into ML ModelsCollaborating to manage data and models
See all domains with question counts →