Courseiva

Google Professional Machine Learning Engineer (PMLE) — Questions 376450

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

Page 5

Page 6 of 14

Page 7
376
MCQeasy

An ML engineer is monitoring a Vertex AI Feature Store used for online serving. Which metrics are most important to track for ensuring low-latency online serving?

A.Number of feature stores and feature values.
B.Storage utilization and write throughput to the feature store.
C.Batch export duration and number of exported features.
D.Feature value retrieval latency (p99) and error rate.
AnswerD

These directly affect online serving performance.

Why this answer

For online serving, the primary concern is the latency and reliability of feature value retrieval at inference time. The p99 retrieval latency directly measures the worst-case delay experienced by users, while the error rate captures failures that could cause serving disruptions. Other metrics like storage utilization or batch export duration are relevant for offline or batch pipelines, not real-time serving.

Exam trap

The trap here is that candidates confuse metrics for offline batch operations (like export duration) with those for online serving, or assume that storage-level metrics (like utilization) are sufficient for performance monitoring, when in fact only retrieval latency and error rate directly reflect the serving quality.

How to eliminate wrong answers

Option A is wrong because the number of feature stores and feature values does not directly impact serving latency; it is a capacity planning metric, not a performance indicator. Option B is wrong because storage utilization and write throughput are important for data ingestion and maintenance, but they do not measure the online retrieval performance that affects inference latency. Option C is wrong because batch export duration and number of exported features pertain to offline batch serving or data export jobs, not the low-latency online serving path.

377
MCQeasy

A data science team uses Vertex AI Workbench and wants to share notebooks with version history. Which service should they use?

A.Artifact Registry
B.Cloud Storage
C.Data Catalog
D.Cloud Source Repositories
AnswerD

Cloud Source Repositories provides Git-based version control for notebooks and code.

Why this answer

Cloud Source Repositories (CSR) is the correct choice because it provides Git-based version control for notebooks, enabling teams to track changes, collaborate, and maintain a full version history. Vertex AI Workbench integrates natively with CSR, allowing users to clone, commit, and push notebook files directly from the JupyterLab interface, which is essential for collaborative development with revision tracking.

Exam trap

Google Cloud often tests the distinction between storage services (Cloud Storage) and version control services (Cloud Source Repositories), leading candidates to choose Cloud Storage because it has object versioning, but it lacks the collaborative Git workflow required for notebook version history.

How to eliminate wrong answers

Option A is wrong because Artifact Registry is designed for storing and managing container images and ML artifacts (e.g., models, packages), not for version-controlling notebook files or providing a Git-based history. Option B is wrong because Cloud Storage is an object store for unstructured data; it supports object versioning but lacks the branching, merging, and collaborative workflow features of a Git repository, making it unsuitable for notebook version history. Option C is wrong because Data Catalog is a metadata management service for discovering and tagging assets (e.g., datasets, models), not a version control system for code or notebooks.

378
MCQhard

An ML engineer is monitoring a model on Vertex AI Endpoint and sees that feature 'age' has a training distribution of (mean=45, std=10) but the serving distribution over the last hour shows (mean=30, std=15). JS divergence is 0.12, but the alert threshold is 0.1. The engineer suspects this is due to a temporary campaign targeting younger users. What should they do first?

A.Use Vertex AI Explainable AI to understand the importance of the 'age' feature for the model.
B.Immediately trigger retraining to avoid model degradation.
C.Increase the sampling rate to get more data before making a decision.
D.Adjust the alert threshold to 0.2 to avoid false positives.
AnswerA

Correct: understand feature importance to decide if drift matters.

Why this answer

Before taking action like retraining, the engineer should investigate the root cause. Using Vertex AI Explainable AI to check feature importance can confirm whether 'age' is a critical feature. If it is not important, the drift may be harmless.

379
Multi-Selecthard

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

Select 2 answers
A.Configure TF_CONFIG for distributed training
B.Set the training worker pool to use only one worker
C.Specify the accelerator type as TPU_V3 and topology as '2x2x4'
D.Use a custom container with TensorFlow 2.12 and TPU support
E.Set the machine type to a high-memory VM with NVIDIA A100 GPUs
AnswersA, C

When using TPU pods with multi-worker, TF_CONFIG must be set to coordinate workers.

Why this answer

Options A and C are correct because TPU pod slices on Vertex AI require setting TF_CONFIG for distributed training (A) and specifying the accelerator type as TPU_V3 with the appropriate topology (C). Option D is not required: Vertex AI provides pre-built containers for TensorFlow that already include TPU support, so a custom container is unnecessary. Using a custom container would be an extra step not needed for this scenario.

Exam trap

A common misconception is that TPU pods can be treated as a single accelerator like a GPU, leading candidates to select a single-worker pool (Option B) or a GPU machine type (Option E), when in fact TPU pod slices require explicit multi-worker topology and TF_CONFIG setup.

380
Multi-Selecthard

An organization is deploying a mission-critical model on Vertex AI Endpoints. They need to ensure high availability and meet a strict SLO of 99.9% uptime. Which THREE steps should they take? (Choose 3)

Select 3 answers
A.Use Cloud CDN to cache responses.
B.Set minReplicas to at least 2 to ensure redundancy within a region.
C.Use a single large instance instead of multiple small ones.
D.Deploy the endpoint in multiple regions.
E.Configure health checks to detect and replace unhealthy instances.
AnswersB, D, E

Multiple replicas in a region protect against instance failures.

Why this answer

To meet a 99.9% SLO, they should deploy across multiple regions for redundancy, set minimum replicas to ensure baseline capacity, and configure health checks to route traffic away from unhealthy instances.

381
MCQmedium

An organization uses Cloud Composer to orchestrate ML workflows. A DAG that triggers Vertex AI training jobs fails because the training job exceeds the 7-day maximum runtime. What is the best way to handle long-running training jobs in Cloud Composer?

A.Increase the DAG execution timeout to 14 days in the Airflow configuration
B.Use Vertex AI Pipeline to manage the training job asynchronously
C.Refactor the training job to run on Dataflow, which supports longer runtimes
D.Set max_active_runs=1 in the DAG to prevent overlapping runs
AnswerB

Vertex AI Pipeline can handle long-running jobs independently of the DAG runtime.

Why this answer

Vertex AI Pipelines natively supports asynchronous execution, allowing Cloud Composer to trigger a pipeline and monitor its status without blocking the Airflow worker for the entire duration of the training job. This decouples the DAG execution timeout from the training runtime, enabling workflows that exceed the 7-day Airflow task timeout limit.

Exam trap

The trap here is that candidates assume increasing the Airflow execution timeout is a valid solution, but the PMLE exam tests understanding that Cloud Composer's architecture imposes practical limits on synchronous task execution, and the correct approach is to use asynchronous orchestration with services like Vertex AI Pipelines.

How to eliminate wrong answers

Option A is wrong because increasing the DAG execution timeout to 14 days does not address the underlying issue: Airflow tasks have a hard-coded maximum runtime of 7 days (configurable via `default_task_retries` and `execution_timeout`, but extending it beyond 7 days is not recommended and can lead to resource exhaustion and scheduler instability). Option C is wrong because Dataflow is a stream and batch processing service, not designed for long-running ML training jobs; its default worker timeout is also limited, and refactoring to Dataflow would not solve the runtime limit issue. Option D is wrong because `max_active_runs=1` prevents overlapping DAG runs but does nothing to extend the maximum runtime of a single task; the training job would still fail after 7 days.

382
MCQeasy

Which of the following is a best practice when designing idempotent pipeline components in Vertex AI?

A.Use global variables to share state between components.
B.Pass data through Cloud Storage URIs rather than in-memory.
C.Write component outputs to a database with timestamps.
D.Use the same output name for all runs to avoid duplication.
AnswerB

GCS URIs make components idempotent and enable caching.

Why this answer

Passing data through Cloud Storage URIs ensures that component outputs are stored persistently and can be retrieved by downstream components, even if the original component instance is terminated or scaled down. This aligns with the principle of idempotency because the same input will always produce the same output stored at the same URI, and re-running the component will not cause side effects or data loss. In contrast, in-memory data is ephemeral and tied to a specific runtime instance, breaking idempotency across retries or parallel executions.

Exam trap

The Google PMLE exam often tests the misconception that idempotency is about avoiding duplication of output names or using timestamps for uniqueness, when in fact idempotency requires that repeated executions produce the same result without side effects, which is achieved by using immutable, deterministic storage like Cloud Storage URIs rather than mutable state or time-dependent writes.

How to eliminate wrong answers

Option A is wrong because using global variables to share state between components introduces mutable shared state that can cause non-deterministic behavior across retries or parallel runs, violating idempotency. Option C is wrong because writing component outputs to a database with timestamps introduces a side effect that changes with each run (different timestamps), making the component non-idempotent; idempotent components should produce the same output regardless of how many times they are executed. Option D is wrong because using the same output name for all runs does not guarantee idempotency; it can lead to overwriting or collision of outputs, and idempotency requires that repeated executions produce the same result without unintended side effects, not just the same output name.

383
MCQmedium

A company is using Vertex AI Pipelines to automate model retraining. They have a component that creates a BigQuery table with training data. To ensure idempotency, the component should check if the table already exists and recreate it if necessary. What is the best practice for passing data between pipeline components?

A.Pass data in-memory as Python objects between components.
B.Use BigQuery table names as component outputs and inputs.
C.Use Cloud SQL to store intermediate results and pass connection strings.
D.Store data as artifacts in Cloud Storage and pass the GCS URI between components.
AnswerD

Correct: Passing GCS URIs allows components to be idempotent and data to be versioned.

Why this answer

Vertex AI Pipelines is designed to pass data between components via Cloud Storage artifacts. By storing the BigQuery table metadata or training data as a file in Cloud Storage and passing the GCS URI as an artifact, the pipeline ensures idempotency and decouples components. This approach aligns with Kubeflow Pipelines' artifact-based I/O model, where each component's outputs are materialized as URIs rather than in-memory objects.

Exam trap

The trap here is that candidates confuse 'passing data' with 'passing references to external services' (like BigQuery table names or Cloud SQL connection strings), but Vertex AI Pipelines expects artifact URIs (typically GCS paths) to maintain pipeline lineage, caching, and reproducibility.

How to eliminate wrong answers

Option A is wrong because Vertex AI Pipelines components run in isolated containers; passing Python objects in-memory is not supported across distributed steps and would break pipeline reproducibility. Option B is wrong because BigQuery table names are not first-class pipeline artifacts; passing them directly couples components to a specific table state and does not leverage Vertex AI's artifact tracking or lineage. Option C is wrong because Cloud SQL introduces unnecessary latency and complexity for intermediate data; Vertex AI Pipelines natively uses Cloud Storage for artifact passing, and connection strings are not a standard pipeline I/O type.

384
MCQeasy

A data scientist has trained a model using Vertex AI Training and wants to deploy it to a Vertex AI Endpoint for online predictions. Which orchestration service should be used to automate the deployment step after training completes?

A.Vertex AI Pipelines
B.App Engine
C.Cloud Functions
D.Cloud Build
AnswerA

Vertex AI Pipelines allows you to define a pipeline with training and deployment components, automating the workflow.

Why this answer

Vertex AI Pipelines is the correct orchestration service because it is purpose-built for automating and managing end-to-end ML workflows on Google Cloud. It allows you to define a pipeline that includes both the training step (using Vertex AI Training) and the subsequent deployment step (creating or updating a Vertex AI Endpoint) as a single, repeatable, and monitored workflow. This ensures that after training completes, the model is automatically deployed without manual intervention, leveraging the pipeline's ability to pass artifacts and trigger conditional logic.

Exam trap

Google Cloud often tests the distinction between general-purpose compute services (Cloud Functions, App Engine) and ML-specific orchestration tools (Vertex AI Pipelines), trapping candidates who think any serverless or CI/CD tool can handle the unique requirements of ML workflow automation.

How to eliminate wrong answers

Option B (App Engine) is wrong because it is a platform-as-a-service (PaaS) for building and hosting web applications, not an ML pipeline orchestrator; it lacks native integration with Vertex AI Training and Endpoint APIs for automated model deployment. Option C (Cloud Functions) is wrong because it is a serverless compute service for event-driven, single-purpose functions, not designed for orchestrating multi-step ML workflows with dependencies and artifact tracking. Option D (Cloud Build) is wrong because it is a CI/CD service primarily for building, testing, and deploying software artifacts (e.g., container images), not for orchestrating ML pipelines that involve training jobs and endpoint deployments with state management.

385
MCQeasy

You are using Cloud Datalab for collaborative data exploration with your team. However, some team members cannot access the Datalab instances. What is the most likely issue?

A.The Datalab instances have been deleted by another team member.
B.The team members need to install the Cloud Datalab SDK locally.
C.The team members have not been granted the necessary IAM roles (e.g., roles/datalab.user) on the project.
D.The Datalab instances were created using an incompatible notebook type.
AnswerC

IAM roles control access to Datalab instances.

Why this answer

Cloud Datalab uses IAM permissions to control access to instances. The most common reason team members cannot access Datalab instances is that they lack the necessary IAM role, such as `roles/datalab.user`, which grants permission to view and connect to Datalab instances. Without this role, even if the instances exist and are running, users will receive permission-denied errors when trying to access them via the Datalab UI or API.

Exam trap

Google Cloud often tests the misconception that Cloud Datalab requires local software installation or that instance deletion is the cause, when in fact the core issue is almost always IAM permissions, specifically the `roles/datalab.user` role.

How to eliminate wrong answers

Option A is wrong because if Datalab instances were deleted, all team members would lose access, not just some, and the error would be a 'not found' rather than an access-denied error. Option B is wrong because Cloud Datalab is a managed service accessed through a web browser; no local SDK installation is required—users simply need the correct IAM permissions and a browser. Option D is wrong because Datalab instances are based on Jupyter notebooks, and there is no concept of 'incompatible notebook type' that would prevent access; the instance type (e.g., machine size) does not affect authentication or authorization.

386
MCQmedium

A team has deployed a model with autoscaling configured as shown. They notice that during off-peak hours, the endpoint consistently runs 3 instances instead of scaling down to 1. What is the most likely cause?

A.There is a sustained request rate that prevents scaling down.
B.The `enableAccessLogging` flag increases resource usage.
C.The `minReplicaCount` is set too high.
D.The model is too large to fit on a single instance.
AnswerA

Autoscaler keeps instances if load requires them, even if low.

Why this answer

The autoscaling configuration is likely based on a target metric (e.g., requests per second or CPU utilization). During off-peak hours, if there is a sustained but low request rate that still exceeds the scale-down threshold, the model will not reduce instances below the number needed to handle that load. The endpoint runs 3 instances because the sustained request rate prevents the scaling-down logic from triggering, even though the traffic is lower than peak.

Exam trap

Google Cloud often tests the misconception that scaling is purely based on instance count or model size, when in reality it is driven by sustained request rates and metric thresholds that prevent scale-down actions.

How to eliminate wrong answers

Option B is wrong because `enableAccessLogging` only controls whether request/response logs are written to CloudWatch (or similar), which does not directly affect compute resource usage or scaling behavior. Option C is wrong because if `minReplicaCount` were set too high, the endpoint would always run at least that many instances, but the question states it runs 3 instances instead of scaling down to 1, implying the minimum is 1 and the scaling logic is failing to reduce further. Option D is wrong because model size affects instance memory and startup time, but it does not prevent scaling down; a large model can still run on a single instance if the instance type supports it.

387
MCQeasy

A marketing team wants to use a pre-built natural language processing (NLP) model from Vertex AI Model Garden to analyze customer feedback. They need to extract sentiment from text data stored in Cloud Storage. The team has no experience with model serving infrastructure. Which deployment option minimizes operational overhead?

A.Deploy the model as a Cloud Function invoked by Cloud Storage events.
B.Deploy the model as a Cloud Run service using a custom Docker container.
C.Deploy the model on App Engine flexible environment.
D.Deploy the model to a Vertex AI Endpoint directly from Model Garden.
AnswerD

Simplest deployment with managed infrastructure.

Why this answer

Deploying directly to a Vertex AI Endpoint from Model Garden eliminates all infrastructure management. Vertex AI handles model serving, scaling, and monitoring automatically, which is ideal for a team with no experience in model serving infrastructure. This is a fully managed, serverless deployment that requires no containerization or server configuration.

Exam trap

The trap here is that candidates often assume Cloud Functions or Cloud Run are simpler because they are 'serverless,' but they fail to recognize that deploying a large NLP model requires specialized infrastructure (GPUs, model serving frameworks) that these services do not natively provide without significant custom work.

How to eliminate wrong answers

Option A is wrong because Cloud Functions are designed for lightweight, stateless event-driven code, not for hosting large NLP models with significant memory and GPU requirements; they also lack built-in model serving capabilities like autoscaling for inference. Option B is wrong because deploying as a Cloud Run service with a custom Docker container requires the team to containerize the model, manage dependencies, and configure scaling, which introduces significant operational overhead for a team with no serving experience. Option C is wrong because App Engine flexible environment still requires the team to build a custom runtime, manage instances, and handle model dependencies, and it is not optimized for ML inference workloads like Vertex AI endpoints.

388
MCQeasy

An organization wants to implement continuous training for a model that serves predictions via Vertex AI Endpoints. Which approach best automates the retrain-deploy cycle?

A.Schedule a Vertex AI Pipeline to retrain and conditionally deploy
B.Use Vertex AI Model Registry to auto-deploy on new model upload
C.Manually retrain and deploy monthly
D.Use Cloud Composer to schedule retraining only
E.Use a Cloud Function to retrain the model and update the endpoint
AnswerA

Automates the full cycle.

Why this answer

Vertex AI Pipelines can be scheduled to run a retraining workflow and include a conditional step that deploys the new model to the endpoint only if it passes validation (e.g., evaluation metrics meet a threshold). This fully automates the retrain-deploy cycle without manual intervention, leveraging the pipeline's orchestration capabilities.

Exam trap

Google Cloud often tests the distinction between partial automation (e.g., only retraining or only deploying) and full end-to-end automation; the trap here is that candidates may choose an option that automates only one part of the cycle (like retraining with Cloud Composer or auto-deployment with Model Registry) and miss that the question requires both retraining and deployment to be automated in a single, orchestrated workflow.

How to eliminate wrong answers

Option B is wrong because Vertex AI Model Registry auto-deploys a model to an endpoint only if the endpoint is configured for automatic deployment, but it does not trigger retraining; it merely deploys an already uploaded model, so it does not automate the retrain step. Option C is wrong because manual retraining and deployment monthly is not automated and defeats the purpose of continuous training. Option D is wrong because Cloud Composer (Airflow) can schedule retraining, but it does not automatically deploy the model to the endpoint; deployment requires an additional step, so it does not fully automate the cycle.

Option E is wrong because a Cloud Function can trigger retraining and update an endpoint, but it lacks built-in orchestration for complex workflows like conditional deployment based on model evaluation, and it is less robust for managing dependencies and state compared to a pipeline.

389
Multi-Selecthard

A team is architecting a low-code ML system for real-time predictions with AutoML. Which THREE considerations are critical for production?

Select 3 answers
A.Enable autoscaling for the endpoint
B.Set up alerts for model performance degradation
C.Monitor prediction drift with Vertex AI Model Monitoring
D.Use a custom container for prediction
E.Use global model endpoints for low latency everywhere
AnswersA, B, C

Correct: Essential for handling variable traffic.

Why this answer

A is correct because autoscaling ensures the prediction endpoint can handle variable request loads without manual intervention, which is critical for production real-time systems. In Vertex AI, you can configure autoscaling with a target utilization level (e.g., 60%) to automatically adjust the number of compute nodes based on incoming traffic, preventing both over-provisioning and latency spikes.

Exam trap

The trap here is that candidates confuse 'low-code' with 'no-code' and assume custom containers (Option D) are always required for production, when AutoML actually abstracts away container management, and they also mistakenly think a single global endpoint inherently provides low latency, ignoring the need for regional deployment and traffic routing.

390
Multi-Selecteasy

Which TWO options are best practices for reducing model serving latency on Vertex AI Endpoints? (Choose two.)

Select 2 answers
A.Use a larger machine type with more memory
B.Optimize the model using quantization or pruning
C.Deploy the model in the same region as the clients
D.Use batch prediction instead of online prediction
E.Enable model caching at the endpoint
AnswersB, C

Reduces model size and inference time, lowering latency with minimal accuracy impact.

Why this answer

Options B and C are correct. Optimizing the model using quantization or pruning reduces the model's size and computational requirements, directly decreasing per-request latency. Deploying the model in the same region as the clients minimizes network round-trip time, reducing overall serving latency.

Option A (larger machine type) may increase throughput but does not necessarily reduce latency per request; Option D (batch prediction) is designed for high throughput, not low latency; Option E (model caching) is not a standard feature of Vertex AI endpoints for reducing latency.

391
MCQeasy

A user receives the error "Deployment failed due to insufficient memory. Please use a machine type with higher memory." when deploying an AutoML model. What should they do?

A.Change the region to us-west1
B.Use machine type n1-highmem-2
C.Increase the min-replica-count to 2
D.Remove the traffic-split flag
AnswerB

Correct: n1-highmem-2 is a supported machine type for AutoML.

Why this answer

When deploying an AutoML model, memory constraints are a common cause of deployment failures. Using a machine type with higher memory, such as n1-highmem-2, helps ensure the model can be loaded and served without out-of-memory errors. The other options do not address memory requirements: changing the region does not affect compute resources, increasing the min replica count does not increase per-instance memory, and removing traffic-split flags does not resolve memory issues.

Exam trap

The trap here is that candidates often confuse scaling (increasing replicas) with resource allocation (increasing memory per replica), leading them to choose Option C instead of addressing the per-instance memory bottleneck.

How to eliminate wrong answers

Option A is wrong because changing the region to `us-west1` does not affect the memory capacity of the machine type; the error is due to insufficient memory, not regional availability or latency. Option C is wrong because increasing `min-replica-count` to 2 only adds more replicas for scaling, but each replica still uses the same underpowered machine type, so the OOM error persists. Option D is wrong because removing the `traffic-split` flag would disrupt traffic routing but does not address the root cause of insufficient memory for model loading.

392
Multi-Selecthard

A team is using Vertex AI Model Monitoring and wants to set up automated retraining when drift is detected. Which THREE services are needed to implement this pipeline? (Choose three.)

Select 3 answers
A.Cloud Scheduler
B.Vertex AI Model Monitoring
C.Cloud Functions
D.Cloud Monitoring
E.Cloud Pub/Sub
AnswersC, D, E

Cloud Functions subscribes to Pub/Sub and invokes the pipeline.

Why this answer

The typical pipeline: Cloud Monitoring alert on drift → Pub/Sub message → Cloud Function or Cloud Run → triggers Vertex AI Pipeline for retraining. Optionally, Cloud Scheduler is not needed as it's event-driven.

393
MCQhard

A company has a pipeline that uses Vertex AI Pipelines to fetch data from BigQuery, preprocess with Dataflow (without code?), then train an AutoML model, and deploy. However, they want to reduce cloud costs. The pipeline runs hourly. Which change will most reduce compute costs while maintaining throughput?

A.Decrease the AutoML training budget from 10 to 1 node hour
B.Replace Dataflow preprocessing with a Cloud Function that runs on each file upload
C.Increase Dataflow batch size to process more data per worker
D.Switch from Vertex AI Pipelines to Cloud Composer for orchestration
AnswerC

Reduces the number of worker instances needed.

Why this answer

Increasing the Dataflow batch size allows each worker to process more data per batch, reducing the number of workers needed and the total compute time for the same throughput. This directly lowers Dataflow's compute cost without affecting the pipeline's hourly schedule or the AutoML training budget.

Exam trap

The trap here is that candidates assume reducing AutoML node hours (Option A) is the most direct way to cut costs, but the question specifies 'maintaining throughput' and the pipeline runs hourly, so Dataflow preprocessing is the dominant cost driver, not the model training budget.

How to eliminate wrong answers

Option A is wrong because decreasing the AutoML training budget from 10 to 1 node hour would severely degrade model quality, as AutoML requires sufficient training time to converge, and this does not address the main cost driver (Dataflow preprocessing). Option B is wrong because replacing Dataflow with a Cloud Function triggered on file upload is event-driven and not suitable for the hourly batch pipeline; Cloud Functions have a 9-minute timeout and cannot handle large-scale preprocessing, so throughput would drop and costs could increase due to per-invocation overhead. Option D is wrong because switching from Vertex AI Pipelines to Cloud Composer (managed Airflow) adds orchestration complexity and cost (e.g., environment nodes) without reducing compute costs for Dataflow or AutoML; the orchestration layer is not the primary cost driver.

394
MCQhard

An organization uses Vertex AI Pipelines to automate a model training workflow. They want to reuse previously trained models if the data hasn't changed. Which pipeline component best achieves this?

A.Use a caching mechanism in Vertex AI Pipelines
B.Use a Cloud Function to check BigQuery update time
C.Use Artifact Registry to store model versions
D.Use a conditional component that checks data hash
AnswerD

A conditional component can explicitly check data hash and skip training if unchanged, making it the best pipeline component for this requirement.

Why this answer

The question asks for a pipeline component. Vertex AI Pipelines caching is a pipeline execution feature that can skip steps based on unchanged inputs, but it is not itself a component. A conditional component is a first-class component that can implement custom logic to check a data hash before deciding whether to run the training step, making it the best choice for this requirement.

Other options: Cloud Functions are external, and Artifact Registry only stores models.

395
MCQeasy

A data scientist is defining a Vertex AI pipeline and needs to include a step that imports a pre-existing model from Cloud Storage into the pipeline as an artifact. Which Kubeflow Pipelines SDK v2 component should they use?

A.dsl.Collected
B.dsl.importer
C.dsl.Importer
D.dsl.Artifact
AnswerB

dsl.importer is used to import existing artifacts into a pipeline.

Why this answer

The `dsl.importer` component in Kubeflow Pipelines SDK v2 is specifically designed to import existing artifacts (such as models, datasets, or metrics) from external storage (e.g., Cloud Storage) into a pipeline as a pipeline artifact. It allows you to reference a pre-existing model without retraining or re-uploading, making it the correct choice for this use case.

Exam trap

The trap here is that candidates may confuse the Python class naming convention (capitalized `Importer`) with the actual SDK v2 function name (lowercase `importer`), or mistakenly think `dsl.Artifact` can import artifacts when it only defines the artifact schema.

How to eliminate wrong answers

Option A is wrong because `dsl.Collected` is not a valid Kubeflow Pipelines SDK v2 component; it does not exist in the API. Option C is wrong because `dsl.Importer` (capital 'I') is not a valid class or function in the SDK v2; the correct name is all lowercase `dsl.importer`. Option D is wrong because `dsl.Artifact` is a base class for defining custom artifact types, not a component for importing artifacts into a pipeline.

396
MCQmedium

A data science team uses TFX to train and deploy a model on Vertex AI. They want automated monitoring for pipeline health. Which set of metrics should they monitor to quickly detect issues in the training pipeline?

A.Prediction request count, latency, and error rate on the serving endpoint.
B.Pipeline execution status (success/failure), component completion times, and data validation anomalies.
C.Number of pipeline runs, average CPU utilization, and memory usage.
D.Model accuracy, precision, and recall on the evaluation dataset.
AnswerB

Directly monitors pipeline health including data quality.

Why this answer

The question specifically asks about monitoring the training pipeline's health, not the serving infrastructure. Pipeline execution status directly indicates whether the pipeline ran successfully, component completion times help identify bottlenecks or failures, and data validation anomalies catch data quality issues early in the pipeline — all of which are essential for detecting issues in the training pipeline itself.

Exam trap

The trap here is that candidates confuse serving endpoint metrics (like latency and error rate) with pipeline health metrics, because both are part of an ML system, but the question explicitly asks about the training pipeline, not the serving infrastructure.

How to eliminate wrong answers

Option A is wrong because prediction request count, latency, and error rate are metrics for monitoring the serving endpoint (model serving), not the training pipeline. Option C is wrong because number of pipeline runs, average CPU utilization, and memory usage are infrastructure-level metrics that do not directly indicate pipeline health or data quality issues. Option D is wrong because model accuracy, precision, and recall are evaluation metrics for model performance, not for detecting issues in the training pipeline's execution or data validation.

397
MCQhard

You are fine-tuning a large language model (LLM) from Hugging Face Transformers using Vertex AI Training. The model has 7 billion parameters and does not fit into the memory of a single GPU. You need to train across multiple GPUs, splitting the model layers across devices. Which distributed training approach should you use?

A.Model parallelism using pipeline parallelism
B.Data parallelism with MultiWorkerMirroredStrategy
C.Mixed precision training (FP16)
D.Data parallelism with tf.distribute.MirroredStrategy
AnswerA

Pipeline parallelism splits layers across devices, allowing large models to fit by distributing the model parameters.

Why this answer

Model parallelism (pipeline parallelism) splits model layers across devices, necessary for large models that don't fit on one GPU. Data parallelism replicates the model and splits data, not suitable if model doesn't fit. Mixed precision reduces memory but still requires model parallelism for 7B.

Fully sharded data parallelism (FSDP) is a form of data parallelism with sharding, but pipeline parallelism is more common for layer-wise splitting.

398
Multi-Selectmedium

Which THREE actions are best practices for managing ML models in production on Google Cloud? (Choose 3)

Select 3 answers
A.Manually tune hyperparameters for each retraining run.
B.Monitor model performance and data drift continuously.
C.Use a central model registry for model governance.
D.Version all model artifacts and training datasets.
E.Store all raw training data indefinitely for auditability.
AnswersB, C, D

Correct: monitoring helps detect degradation.

Why this answer

Continuous monitoring of model performance and data drift is essential for maintaining prediction accuracy in production. Google Cloud's Vertex AI Model Monitoring automatically detects skew and drift by comparing serving data against training data distributions, alerting you to degradation before it impacts business outcomes.

Exam trap

Google Cloud often tests the misconception that manual hyperparameter tuning is acceptable for production, when in fact automation (e.g., Vertex AI Vizier) is the recommended practice to ensure reproducibility and efficiency.

399
Multi-Selecthard

A company runs batch predictions on a large dataset using Vertex AI Batch Prediction. They want to reduce costs without significantly increasing processing time. Which three actions should they take? (Choose three.)

Select 3 answers
A.Use preemptible VMs for the batch prediction job.
B.Use a larger machine type to reduce the number of workers.
C.Use custom machine types with only the necessary resources (vCPU and memory).
D.Use TPUs instead of GPUs to accelerate processing.
E.Tune the batch size to maximize throughput per worker.
AnswersA, C, E

Use preemptible VMs for the batch prediction job — they are significantly cheaper than regular VMs, reducing costs without affecting processing time significantly.

Why this answer

Options A, C, and E are correct. A uses preemptible VMs which are cheaper. C uses custom machine types to avoid overprovisioning and reduce costs.

E tunes batch size to maximize throughput per worker, reducing the number of workers needed. Option B increases machine size, which may increase cost per worker. Option D uses TPUs, which are more expensive and may not be beneficial for all model types.

400
Multi-Selectmedium

Which TWO metrics should you monitor to detect data drift in a batch prediction pipeline?

Select 2 answers
A.Model accuracy on recent labeled data
B.Model prediction latency
C.Feature distribution drift (e.g., KS test)
D.Prediction distribution drift
E.Training data size
AnswersC, D

Directly measures input drift.

Why this answer

Feature distribution drift (C) is correct because it directly measures changes in the input data distribution over time using statistical tests like the Kolmogorov-Smirnov (KS) test, which compares the cumulative distribution of a feature in the current batch against a reference baseline. This is a primary indicator of data drift, as shifts in feature distributions can degrade model performance even if labels are not immediately available.

Exam trap

Google Cloud often tests the distinction between monitoring for data drift (input distribution changes) versus monitoring for model performance degradation (accuracy), leading candidates to incorrectly select accuracy as a drift metric when it is actually a downstream effect.

401
MCQhard

A machine learning team is deploying a PyTorch model on Vertex AI Prediction for real-time inference. The model was trained with preprocessing that includes tokenization and normalization. They want to embed the preprocessing logic in the model to reduce prediction latency and avoid additional service calls. Which approach should they take?

A.Deploy the preprocessing logic as a Cloud Function and invoke it before calling the prediction endpoint
B.Wrap the preprocessing logic in a Flask application and deploy it as a separate microservice in front of the prediction endpoint
C.Use TorchScript to trace the preprocessing steps and export the entire pipeline as a single scripted model
D.Use TensorFlow Transform to convert preprocessing into a SavedModel and call it from the PyTorch model
AnswerC

TorchScript compiles PyTorch code into a graph that can be run efficiently in C++ runtime, ideal for production serving.

Why this answer

TorchScript allows exporting the entire model (including preprocessing) into a serialized format that can be run without Python dependencies. This reduces latency as all operations are within the exported graph. Wrapping in a Flask app or using Cloud Functions would introduce overhead.

Training with tf.Transform is not applicable for PyTorch.

402
MCQmedium

A company uses Vertex AI AutoML to train a vision model, but the model has low accuracy. What should they do first?

A.Add more labeled images to the dataset
B.Switch to a custom model
C.Increase the training budget
D.Reduce image size to speed up training
AnswerA

More data often improves model accuracy.

Why this answer

Adding more labeled images directly addresses the most common cause of low accuracy in AutoML vision models: insufficient or unrepresentative training data. Vertex AI AutoML relies on transfer learning from pre-trained models, and its performance is heavily dependent on the quality and quantity of labeled examples. Before adjusting hyperparameters or infrastructure, the first step should always be to improve the dataset, as AutoML is designed to handle model architecture and training budget automatically.

Exam trap

Google Cloud often tests the misconception that AutoML models are 'black boxes' where tuning budgets or switching to custom models is the first fix, when in reality the platform is optimized to handle those aspects automatically, and the primary lever is data quality.

How to eliminate wrong answers

Option B is wrong because switching to a custom model would require manual architecture design and hyperparameter tuning, which contradicts the low-code premise of AutoML and is not the first troubleshooting step. Option C is wrong because increasing the training budget (e.g., node hours) only helps if the model has not converged; with low accuracy, the root cause is typically data quality, not insufficient training time. Option D is wrong because reducing image size may speed up training but can discard critical features, further degrading accuracy; AutoML already handles resizing internally.

403
Multi-Selecteasy

You need to deploy a model for online predictions with low latency. You want to ensure that the endpoint can handle traffic bursts without cold start. Which TWO configurations should you set? (Choose 2)

Select 2 answers
A.Set maxReplicas to a high number to handle bursts.
B.Set minReplicas to 1.
C.Deploy the model as a custom container.
D.Enable autoscaling with a target CPU utilisation of 30%.
E.Use a machine type with sufficient memory for the model.
AnswersB, E

Correct. This ensures at least one instance is always running, avoiding cold start.

Why this answer

To avoid cold start, you must keep at least one replica always running (minReplicas ≥ 1) and ensure that the machine type has enough capacity. Setting minReplicas to 0 would cause cold start. Also, setting a higher CPU utilisation target may help but not directly avoid cold start.

404
MCQhard

You are fine-tuning a pre-trained model using transfer learning. The new dataset is small and very similar to the original training data. To avoid overfitting, which layer freezing strategy should you adopt?

A.Unfreeze the last few layers and freeze the rest
B.Randomly reinitialise all layers and train from scratch
C.Freeze all layers and train only the classifier head
D.Unfreeze all layers and train the entire model
AnswerC

Minimises overfitting by limiting trainable parameters; features are already good.

Why this answer

When fine-tuning a pre-trained model on a small dataset that is very similar to the original training data, the safest strategy to avoid overfitting is to freeze all layers and train only the classifier head. This preserves the rich, general-purpose feature representations learned from the original large dataset, while allowing the final classification layer to adapt to the new task. Training the entire model or unfreezing many layers on a small dataset would risk overfitting because the model would have too many parameters to update relative to the limited new samples.

Exam trap

A common pitfall in this exam is the misconception that unfreezing more layers always yields better fine-tuning performance. However, with a small, similar dataset, freezing all layers except the classifier head is the correct regularization strategy to prevent overfitting, not a sign of underfitting.

How to eliminate wrong answers

Option A is wrong because unfreezing the last few layers still updates a significant number of parameters, which can lead to overfitting when the new dataset is very small and similar to the original data; the risk is that the model will memorize the small dataset rather than generalize. Option B is wrong because randomly reinitializing all layers and training from scratch discards all the pre-trained knowledge, which defeats the purpose of transfer learning and, with a small dataset, will almost certainly result in severe overfitting or failure to converge. Option D is wrong because unfreezing all layers and training the entire model on a small dataset is the most aggressive overfitting scenario, as it allows every parameter to be updated, making the model highly likely to memorize the training examples instead of learning generalizable features.

405
MCQhard

An ML engineer is using Vertex AI distributed training for a TensorFlow model that uses the MirroredStrategy. They notice that the training throughput drops significantly when moving from a single GPU to multiple GPUs on the same machine. What is the most likely cause?

A.The GPUs are not properly configured in TF_CONFIG.
B.The batch size is too small, causing each GPU to complete its forward pass quickly, but the sync wait dominates.
C.The learning rate is too high, causing instability.
D.The model uses TensorFlow 1.x instead of 2.x.
AnswerB

With small batch sizes, GPUs are underutilized, and sync overhead becomes significant.

Why this answer

MirroredStrategy synchronously updates gradients across GPUs. The overhead of gradient synchronization (all-reduce) can become a bottleneck if the model is small or the network between GPUs is slow. This is a common issue.

406
MCQmedium

You are using DVC for data versioning in an ML project on Google Cloud. Your training data is stored in Cloud Storage. You want to track a new version of the dataset after preprocessing. Which DVC command should you use to register the changes?

A.dvc add data/processed
B.dvc push
C.dvc run -n preprocess
D.dvc commit
AnswerA

dvc add tracks the dataset and creates a .dvc file, versioning the data.

Why this answer

DVC tracks data versions via 'dvc add' which creates a .dvc file that points to the data in Cloud Storage. 'dvc run' is for pipelines, 'dvc push' uploads cached data to remote storage, and 'dvc commit' saves changes to DVC-tracked files after a pipeline run.

407
Multi-Selectmedium

An ML team is optimizing an inference model for deployment on edge devices. They need to reduce the model size and improve latency while maintaining accuracy as much as possible. Which two techniques should they use? (Choose TWO.)

Select 2 answers
A.Use a larger pre-trained model as a starting point.
B.Post-training quantization to INT8.
C.Use half-precision (FP16) instead of INT8.
D.Apply weight pruning to remove small weights.
E.Increase the number of layers in the model.
AnswersB, D

Reduces size and latency with minimal accuracy loss.

Why this answer

Post-training quantization to INT8 reduces model size by converting 32-bit floating-point weights and activations to 8-bit integers, which also speeds up inference on edge devices with integer-optimized hardware. This technique typically maintains accuracy within 1-2% of the original model while significantly lowering memory footprint and latency.

Exam trap

Candidates often think that FP16 is always better than INT8 for edge devices, but INT8 offers greater size reduction and is more widely supported on edge hardware, including Google's Edge TPU.

408
MCQmedium

An ML team is scaling a prototype to production. The data pipeline currently reads from Cloud Storage and transforms data with a custom Python script. They need to handle higher throughput and add monitoring. Which approach should they take?

A.Deploy the Python script on a large Compute Engine instance with a cron job
B.Migrate the pipeline to Apache Beam on Dataflow with Cloud Monitoring
C.Rewrite the pipeline to use Pub/Sub and Cloud Functions for processing
D.Use Cloud Composer to orchestrate the Python script at scale
AnswerB

Dataflow is serverless, auto-scales, and integrates with Cloud Monitoring for observability.

Why this answer

Apache Beam on Dataflow provides a unified programming model for batch and streaming data processing, enabling automatic scaling to handle higher throughput. Cloud Monitoring integrates natively with Dataflow to track pipeline metrics, latency, and error rates, addressing the monitoring requirement. This approach is purpose-built for production-grade data pipelines, unlike ad-hoc solutions.

Exam trap

Google Cloud often tests the distinction between orchestration (Cloud Composer) and execution (Dataflow), leading candidates to choose an orchestrator when a dedicated processing engine is required for scaling and monitoring.

How to eliminate wrong answers

Option A is wrong because deploying a Python script on a single large Compute Engine instance with a cron job does not provide horizontal scaling, fault tolerance, or built-in monitoring; it creates a single point of failure and cannot handle throughput spikes. Option C is wrong because rewriting the pipeline to use Pub/Sub and Cloud Functions is suitable for event-driven, lightweight processing but not for complex data transformations or high-throughput batch workloads; Cloud Functions have timeouts (up to 9 minutes for HTTP functions) and lack stateful processing capabilities. Option D is wrong because Cloud Composer (managed Apache Airflow) is an orchestration tool, not a data processing engine; it would still rely on the Python script's execution, inheriting its scaling and monitoring limitations without addressing the core transformation throughput.

409
MCQhard

A company has a Vertex AI pipeline that trains a model on streaming data from Pub/Sub. The pipeline is triggered by a Cloud Function when new data arrives. Recently, jobs have been failing with 'ResourceExhausted: Quota limit exceeded for regional CPUs in us-central1.' The team needs to ensure successful job execution while minimizing changes. Which approach should they take?

A.Request a quota increase from Google Cloud Support.
B.Change the pipeline to run in a different region with available quota.
C.Reduce the number of parallel pipeline runs by using a Cloud Tasks queue with rate limiting.
D.Configure the pipeline's training job to use preemptible VMs (which count toward a separate, usually higher quota).
AnswerD

Preemptible VMs have a separate quota and are cheaper.

Why this answer

Preemptible VMs count toward a separate, often higher quota for 'Preemptible CPUs' rather than the standard regional CPU quota. By configuring the training job to use preemptible VMs, the team can bypass the exhausted quota without requesting a limit increase or changing the pipeline architecture. This minimizes changes while leveraging the fact that Vertex AI training jobs can be configured to use preemptible VMs via the `worker_pool_specs` with `accelerator_type` and `machine_type` settings.

Exam trap

Google Cloud often tests the misconception that rate limiting (Option C) solves quota exhaustion, but the trap here is that quota limits are per-resource (e.g., regional CPUs) and rate limiting does not change the per-job resource consumption, so it only delays the inevitable failure.

How to eliminate wrong answers

Option A is wrong because requesting a quota increase from Google Cloud Support is a manual, time-consuming process that does not minimize changes and may not be approved quickly, especially if the quota is already at a high default limit. Option B is wrong because changing the pipeline to run in a different region introduces significant architectural changes, potential latency issues, and may require reconfiguring data sources like Pub/Sub topics and Cloud Functions, which contradicts the goal of minimizing changes. Option C is wrong because reducing the number of parallel pipeline runs with a Cloud Tasks queue addresses concurrency but does not resolve the underlying regional CPU quota exhaustion; the quota limit is still hit per run, and rate limiting only delays failures rather than preventing them.

410
MCQhard

A company is using Vertex AI Prediction with a custom container that performs preprocessing before inference. The preprocessing step is CPU-intensive and the inference step uses a GPU. They want to minimize prediction latency while optimizing cost. Which architecture should they use?

A.Use Cloud Run for preprocessing and send HTTP requests to a GPU-backed Vertex AI endpoint for inference.
B.Use two separate Vertex AI endpoints: one CPU-based for preprocessing, one GPU-based for inference, and chain them with Cloud Tasks.
C.Use Dataflow for preprocessing and then invoke the model, but Dataflow is not designed for real-time prediction.
D.Use a single GPU machine (e.g., n1-standard-4 with T4) and perform both preprocessing and inference on the same instance.
AnswerD

This minimizes latency by keeping all processing local, and you can choose a machine with sufficient CPU cores.

Why this answer

Using a CPU-only node for preprocessing and then sending the preprocessed data to a GPU node for inference separates concerns and allows independent scaling, but adds network latency. The best approach is to use a single machine with both CPU and GPU to avoid network round-trip, and to adjust the machine type to have enough CPU resources.

411
MCQhard

You are a machine learning engineer at a retail company. You have deployed a product recommendation model on Vertex AI Prediction using a custom container. The model is a TensorFlow SavedModel that computes embeddings using a large lookup table. The endpoint is configured with 2 replicas on n1-standard-4 (4 vCPU, 15 GB memory) machines. After deployment, you notice that the endpoint's memory usage grows over time, eventually reaching 90% and causing requests to fail with 503 errors. The container logs show no errors, but the memory usage graph shows a steady increase. The model loads the embedding table (5 GB) at startup. You suspect a memory leak. Which course of action should you take first to diagnose and resolve the issue?

A.Profile the container's memory usage locally with memory_profiler to find the leak, then fix the code.
B.Reduce the number of replicas to 1 to reduce memory contention.
C.Increase the machine memory to n1-standard-8 (30 GB).
D.Restart the endpoint every hour using a Cloud Scheduler job.
AnswerA

Identifies root cause for permanent fix.

Why this answer

The steady memory growth despite a fixed 5 GB embedding table indicates a memory leak in the custom container code, not a capacity issue. Profiling locally with memory_profiler allows you to trace object allocations and identify the leak source before modifying the serving code, which is the most direct diagnostic step.

Exam trap

Google Cloud often tests the distinction between scaling up resources (Option C) and fixing the root cause (Option A), tempting candidates to choose a quick capacity increase instead of proper debugging.

How to eliminate wrong answers

Option B is wrong because reducing replicas to 1 does not address the memory leak; it only reduces total cluster memory, making the leak more severe per replica. Option C is wrong because increasing machine memory to n1-standard-8 (30 GB) merely postpones the failure by providing more headroom, but the leak will eventually consume that memory as well. Option D is wrong because restarting the endpoint every hour via Cloud Scheduler is a workaround that masks the symptom without fixing the underlying code defect, and it introduces request downtime during restarts.

412
MCQeasy

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

A.Vertex AI Model Garden
B.Vertex AI Endpoints
C.Vertex AI AutoML
D.Vertex AI JumpStart
AnswerD

JumpStart offers one-click deployment of foundation models.

Why this answer

Vertex AI JumpStart provides one-click deployment of foundation models and ML solutions. It allows deploying pre-trained models without coding.

413
MCQhard

Your team is deploying a large language model (LLM) on Vertex AI for online prediction. The model exceeds the maximum request size for Vertex AI Prediction. Which approach should you take to serve this model?

A.Use Vertex AI Endpoint with a larger machine type and gRPC
B.Use Vertex AI Batch Prediction
C.Split the model into smaller parts and deploy multiple endpoints
D.Deploy the model on a Compute Engine VM with a custom container and a load balancer
AnswerD

Bypasses Vertex AI Prediction limits; you can handle large payloads.

Why this answer

Vertex AI Prediction has a request size limit (1.5 MB). Using a custom container with a ModelServer (e.g., TensorFlow Serving) behind an HTTP load balancer bypasses this limit and allows large payloads.

414
Multi-Selectmedium

A data science team uses Cloud Composer to orchestrate a complex ML workflow. They need to run a Vertex AI pipeline and then a BigQuery query conditionally based on the pipeline's output. Which Airflow features should they use? (Choose two.)

Select 2 answers
A.BigQueryExecuteQueryOperator
B.Task dependencies using >>
C.dsl.If
D.VertexAIPipelineJobOperator
E.PythonOperator with if-else
AnswersD, E

This operator runs a Vertex AI pipeline.

Why this answer

VertexAIPipelineJobOperator (D) runs the Vertex AI pipeline. To conditionally run a BigQuery query based on the pipeline's output, you can use a PythonOperator (E) with if-else logic to check the output and then execute the BigQuery query within the Python task, for example by using the BigQuery client library. This avoids the need for a separate branching operator.

Therefore, the correct features are D and E.

415
MCQhard

Refer to the exhibit. A data scientist deploys a new model version (model_v2) to an existing endpoint with 20% traffic. After a few days, they notice that model_v2's error rate is higher than model_v1's. They want to route all traffic back to model_v1 immediately. Which command achieves this with minimal disruption?

A.gcloud ai endpoints update my-endpoint --region=us-central1 --remove-deployed-model=model_v2
B.gcloud ai endpoints undepoly-model my-endpoint --region=us-central1 --model=model_v2
C.gcloud ai endpoints update my-endpoint --region=us-central1 --traffic-split=model_v1=1,model_v2=0
D.gcloud ai endpoints update-traffic my-endpoint --region=us-central1 --model=model_v1 --traffic-percentage=100
AnswerC

This command updates the traffic split to direct 100% traffic to model_v1 and 0% to model_v2, a zero-downtime change.

Why this answer

The `gcloud ai endpoints update` command with the `--traffic-split` flag allows you to set the traffic distribution among deployed models. By specifying `model_v1=1,model_v2=0`, all traffic is immediately routed to model_v1 without removing or redeploying any models, minimizing disruption. Option A is incorrect because `--remove-deployed-model` removes the model entirely, which may cause downtime if not re-deployed, and the command syntax is not valid for traffic rerouting.

Option B has a misspelled subcommand (`undepoly` instead of `undeploy`) and would undeploy the model, causing temporary unavailability. Option D uses an invalid command (`update-traffic`) and syntax; the correct approach is to use `--traffic-split` on the update command.

416
MCQmedium

You have deployed a regression model that predicts house prices. Over the past month, the model's predictions have been consistently too high. You suspect data drift in the input features. Which monitoring metric should you prioritize to confirm this?

A.Monitor prediction drift (prediction distribution)
B.Monitor feature distribution drift using a divergence metric like Jensen-Shannon divergence
C.Monitor feature attribution drift using SHAP values
D.Monitor residual distribution drift
AnswerB

Feature drift measures input distribution change.

Why this answer

The question describes a scenario where predictions are consistently too high, which is a symptom of data drift—a change in the distribution of input features. Monitoring feature distribution drift using a divergence metric like Jensen-Shannon divergence directly measures whether the input data has shifted from the training distribution, which would cause the model to make biased predictions. This is the most direct way to confirm data drift in the input features.

Exam trap

Google Cloud often tests the distinction between monitoring prediction drift (output) and feature drift (input), trapping candidates who assume that a change in predictions automatically implies data drift without verifying the input distributions.

How to eliminate wrong answers

Option A is wrong because monitoring prediction drift (prediction distribution) only tells you that the outputs have changed, not why; it does not isolate whether the cause is data drift in features or other issues like concept drift. Option C is wrong because monitoring feature attribution drift using SHAP values measures changes in feature importance, not changes in the feature distributions themselves; it can indicate which features are driving predictions differently but does not directly confirm data drift. Option D is wrong because monitoring residual distribution drift focuses on the errors (residuals) between predictions and actual values, which can be influenced by both data drift and concept drift; it does not specifically confirm data drift in input features.

417
Matchingmedium

Match each Google Cloud AI/ML service to its primary purpose.

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

Concepts
Matches

End-to-end ML platform for building, deploying, and managing models

Train high-quality custom ML models with minimal effort

Managed service for distributed training of ML models

Custom ASIC for accelerating ML training workloads

Create and execute ML models using SQL queries

Why these pairings

In this matching question, the correct pairings are: Option A (Vertex AI: End-to-end ML platform) is correct because Vertex AI unifies the ML workflow. Option C (Cloud AutoML: Train custom ML models with minimal coding) is correct because AutoML provides no-code training. Option E (Vision API: Analyze images for objects, faces, text) is correct because Vision API specializes in image analysis.

Option B is wrong because Vertex AI is not primarily for graphical no-code training—that is AutoML's strength. Option D is wrong because Cloud AutoML is not an end-to-end platform—that's Vertex AI. Option F is wrong because Vision API does not analyze text; that is the Natural Language API's purpose.

Exam trap

Candidates often confuse Vertex AI with Cloud AutoML, thinking Vertex AI is only for no-code training or that AutoML is the end-to-end platform. Remember: Vertex AI is the unified platform; AutoML is a component for no-code model training.

418
MCQmedium

A retail company wants to build a product recommendation system using customer purchase history and product attributes. They have limited ML expertise and want to minimize custom code. Which approach should they choose?

A.Use BigQuery ML to create a matrix factorization model.
B.Use Vertex AI Vizier for hyperparameter tuning on a pre-built recommendation model.
C.Use Vertex AI AutoML Tables to train a recommendation model.
D.Use TensorFlow with Keras to build a custom collaborative filtering model.
AnswerC

AutoML Tables can build a recommendation model from tabular data with minimal code.

Why this answer

Vertex AI AutoML Tables is the correct choice because it enables building a recommendation model with minimal ML expertise and custom code, leveraging automated feature engineering, model selection, and hyperparameter tuning on tabular data (customer purchase history and product attributes). It requires no custom code, unlike TensorFlow/Keras, and provides a managed service that handles data preprocessing and training, aligning with the company's limited ML expertise and desire to minimize custom code.

Exam trap

Google Cloud often tests the distinction between model training services (AutoML, BigQuery ML) and optimization/tuning services (Vizier), leading candidates to confuse Vizier as a complete model-building solution when it only tunes hyperparameters for an existing model.

How to eliminate wrong answers

Option A is wrong because BigQuery ML's matrix factorization model is designed for explicit feedback (e.g., ratings) and requires structured SQL-based feature engineering, which still demands ML knowledge and custom SQL code, not a fully low-code solution. Option B is wrong because Vertex AI Vizier is a hyperparameter tuning service, not a model training service; it cannot build a recommendation model on its own and requires a pre-built model to tune, which the company lacks. Option D is wrong because TensorFlow with Keras requires significant custom code and ML expertise to implement collaborative filtering, contradicting the requirement to minimize custom code and limited ML expertise.

419
Multi-Selectmedium

A company uses Cloud Scheduler to trigger Cloud Functions that submit Vertex AI training jobs. They want to ensure fault tolerance and minimize manual intervention. Which TWO practices should they implement?

Select 2 answers
A.Store training hyperparameters in Cloud Firestore for reproducibility.
B.Use Cloud Run jobs as an alternative execution environment.
C.Use Cloud Tasks with retries to handle failed triggers.
D.Implement a fallback that runs the job on Compute Engine if Vertex AI fails.
E.Set up Cloud Monitoring alerts on failed pipeline runs.
AnswersC, E

Cloud Tasks can schedule and retry HTTP requests to the Cloud Function, providing fault tolerance.

Why this answer

Cloud Tasks provides built-in retry logic with exponential backoff, which can reliably handle transient failures when triggering Cloud Functions from Cloud Scheduler. By configuring a Cloud Tasks queue with retry parameters, the system automatically retries failed triggers without manual intervention, ensuring fault tolerance for Vertex AI training job submissions.

Exam trap

Google Cloud often tests the distinction between fault tolerance (retry mechanisms) and other concerns like reproducibility or alternative compute; the trap here is that candidates may confuse storing hyperparameters (reproducibility) or switching to Compute Engine (fallback) with actual fault tolerance for trigger failures.

420
Multi-Selectmedium

A data science team uses Vertex AI Experiments to compare multiple model training runs. They want to capture and compare hyperparameters, metrics, and code versions for each run. Which TWO steps should they take?

Select 2 answers
A.Use Cloud Logging to capture all training outputs
B.Store code versions in Cloud Storage and link them to experiments manually
C.Log hyperparameters and metrics using the Vertex AI SDK's experiment logging functions
D.Export experiment data to BigQuery for comparison
E.Integrate the training code with Git and use the commit hash as a run parameter
AnswersC, E

SDK functions allow logging to Experiments for comparison.

Why this answer

Using the Vertex AI SDK to log parameters and metrics enables comparison. Integrating with a version control system like Git ensures code version tracking.

421
Multi-Selectmedium

A team has trained a sentiment analysis model using PyTorch on Vertex AI Training. They now want to deploy it for online predictions with low latency. Which TWO actions should they take? (Choose 2)

Select 2 answers
A.Create multiple model versions for A/B testing.
B.Use a machine type with a GPU for faster inference.
C.Enable batch prediction instead of online prediction.
D.Convert the model to TensorFlow SavedModel format.
E.Package the model in a custom container with a web server (e.g., FastAPI).
AnswersB, E

GPUs can accelerate inference for deep learning models.

Why this answer

GPU-accelerated inference significantly reduces latency for deep learning models like sentiment analysis, especially when using PyTorch, which has native CUDA support. Vertex AI Prediction supports GPU machine types (e.g., n1-standard-4 with NVIDIA T4) that can process batched requests faster than CPUs, directly addressing the low-latency requirement.

Exam trap

Google Cloud often tests the misconception that converting to TensorFlow SavedModel is required for Vertex AI, but the platform supports PyTorch natively via custom containers, making conversion an unnecessary and potentially error-prone step.

422
MCQhard

A large e-commerce company deploys a recommendation model on Vertex AI with autoscaling enabled. During Black Friday, traffic spikes rapidly. The autoscaler adds new instances, but new instances take several minutes to become ready (cold start). As a result, many requests time out. What should they do to mitigate this issue?

A.Use a larger machine type to reduce the number of instances needed.
B.Configure the autoscaler to use CPU utilization metric instead of request count.
C.Increase the health check grace period for new instances.
D.Set a higher minimum number of instances to handle the expected peak.
AnswerD

Pre-warms instances to absorb traffic spikes without cold start.

Why this answer

Setting a higher minimum number of instances ensures that a baseline capacity is always running and ready to serve traffic. This pre-warms instances, eliminating the cold-start latency during rapid traffic spikes, such as Black Friday, because new instances do not need to initialize from scratch.

Exam trap

The trap here is that candidates confuse scaling metrics or instance readiness with the fundamental need for pre-provisioned capacity, leading them to choose options that adjust autoscaling behavior without eliminating the cold-start latency.

How to eliminate wrong answers

Option A is wrong because using a larger machine type reduces the number of instances needed but does not address the cold-start delay; each new instance still takes minutes to become ready. Option B is wrong because switching to CPU utilization metric does not solve the cold-start problem; the autoscaler still adds instances that take time to initialize, and CPU utilization may not react as quickly to a sudden traffic surge as request count. Option C is wrong because increasing the health check grace period only delays when the load balancer considers an instance healthy, but the instance still takes the same time to become ready; requests will still time out during the cold-start window.

423
Multi-Selectmedium

A data scientist needs to scale a prototype deep learning model to train on a massive dataset using multiple GPUs. Which three strategies are essential for efficient distributed training? (Select THREE)

Select 3 answers
A.Use a single large batch size across all workers.
B.Implement data parallelism.
C.Ensure that the input pipeline is not a bottleneck by using tf.data.Dataset with prefetching and parallel reads.
D.Use synchronous gradient updates.
E.Use asynchronous gradient updates to reduce communication overhead.
AnswersB, C, D

Scales training by splitting data across workers.

Why this answer

The correct strategies are B (data parallelism), C (optimized input pipeline with tf.data.Dataset), and D (synchronous gradient updates). Data parallelism is the foundation for distributing training across multiple GPUs. Synchronous gradient updates ensure consistency and convergence.

An optimized input pipeline prevents I/O bottlenecks. Option A (single large batch size) is not essential, and option E (asynchronous updates) can lead to poor convergence.

424
MCQeasy

An MLOps team wants to automate the retraining of a model each time new data arrives in a BigQuery table. What is the most efficient Google Cloud service to orchestrate this pipeline?

A.Cloud Composer with an Airflow DAG
B.Dataflow pipeline with a periodic trigger
C.Cloud Functions triggered by BigQuery events
D.Vertex AI Pipelines with a schedule trigger
AnswerD

Vertex AI Pipelines natively supports scheduled triggers and is the recommended service for ML pipeline orchestration.

Why this answer

Vertex AI Pipelines is purpose-built for orchestrating ML workflows, including model retraining. It integrates natively with BigQuery for data ingestion and supports schedule triggers to automate retraining upon new data arrival, making it the most efficient and managed option for this ML-specific task.

Exam trap

The trap here is that candidates often confuse event-driven triggers with BigQuery's lack of native row-level or table-level event notifications, leading them to incorrectly choose Cloud Functions or Dataflow, while Vertex AI Pipelines provides the most integrated and efficient orchestration for ML retraining workflows.

How to eliminate wrong answers

Option A is wrong because Cloud Composer (Airflow) is a general-purpose workflow orchestrator that adds unnecessary overhead and complexity for a simple retraining pipeline, and it is not optimized for ML-specific operations like model versioning and deployment. Option B is wrong because Dataflow is a stream/batch data processing service, not an orchestrator; a periodic trigger would require additional services (e.g., Cloud Scheduler) and does not natively handle model retraining or pipeline orchestration. Option C is wrong because Cloud Functions triggered by BigQuery events cannot directly trigger BigQuery events (BigQuery does not emit event-driven triggers for new table data); this option reflects a misunderstanding of BigQuery's event capabilities.

425
MCQmedium

A machine learning engineer has a Vertex AI pipeline that trains a model. The pipeline uses caching to avoid re-running components that have not changed. After updating the training code, the engineer notices that the pipeline still uses cached outputs from the previous run. What could be the reason?

A.The pipeline parameter values have changed, causing a cache hit.
B.The pipeline is using a pre-built component that ignores caching.
C.The base image used for the component has not changed, so the cache key matches despite code changes inside the container.
D.The component has caching disabled via the @dsl.component decorator.
AnswerC

The cache key includes the base image digest; if only the code inside the container changes but the image tag/digest remains the same, the cache key may still match.

Why this answer

In Vertex AI Pipelines, caching uses a cache key derived from the component source code, input parameters, and the base image digest. If only the training code inside the container changes but the base image digest remains the same, the cache key does not change, resulting in a cache hit from the previous run. This explains why the pipeline still uses cached outputs.

Option A is incorrect because changing parameter values would change the cache key, causing a miss. Option B is incorrect because pre-built components support caching unless explicitly disabled. Option D would disable caching entirely, which is not the case here.

426
MCQeasy

A machine learning engineer wants to use Vertex AI Vizier to tune three hyperparameters: learning rate (log scale), number of layers (integer), and optimizer (categorical). They have 50 parallel trials available. Which parameter specification types should they define?

A.learning_rate: CATEGORICAL, layers: INTEGER, optimizer: CATEGORICAL
B.learning_rate: DOUBLE (unit_log_scale), layers: INTEGER (unit_linear_scale), optimizer: CATEGORICAL
C.learning_rate: DOUBLE (unit_log_scale), layers: DOUBLE (unit_linear_scale), optimizer: DISCRETE
D.learning_rate: DOUBLE (unit_linear_scale), layers: INTEGER (unit_linear_scale), optimizer: CATEGORICAL
AnswerB

Correct types and scales for the parameters.

Why this answer

In Vertex AI Vizier, continuous parameters use DOUBLE type (can be scaled log), integer parameters use INTEGER, and categorical parameters use CATEGORICAL. The scale type for learning rate should be UNIT_LOG_SCALE for log scale.

427
MCQmedium

An ML engineer needs to deploy a model to an endpoint and gradually shift traffic from the previous version (champion) to a new version (challenger) for A/B testing. How should they configure the endpoint?

A.Use a canary deployment with Cloud Run
B.Manually update the endpoint to point to the challenger after testing
C.Create a new endpoint for the challenger and route traffic via load balancer
D.Deploy both versions to the same endpoint and set traffic splitting
AnswerD

Vertex AI allows splitting traffic across deployed models.

Why this answer

Vertex AI endpoints support traffic splitting by assigning percentages to different model versions.

428
Multi-Selecteasy

A company is deploying a machine learning model for real-time inference on Vertex AI. Which TWO practices improve serving performance and reliability?

Select 2 answers
A.Use batch prediction for all requests.
B.Enable autoscaling to handle traffic variations.
C.Use manual scaling with a fixed number of replicas.
D.Deploy all models on the same machine type for consistency.
E.Set up model monitoring for prediction drift and data quality.
AnswersB, E

Autoscaling adjusts resources dynamically.

Why this answer

Vertex AI's autoscaling dynamically adjusts the number of replicas based on incoming request traffic, ensuring low latency during spikes and cost savings during lulls. This is critical for real-time inference, where consistent response times are required and manual scaling would either over-provision or under-provision resources. Autoscaling uses metrics like CPU utilization or request count to scale up or down, directly improving serving performance and reliability.

Exam trap

Google Cloud often tests the distinction between batch and real-time serving, trapping candidates who think batch prediction can be used for low-latency inference, or who assume that manual scaling is more reliable than autoscaling for variable workloads.

429
MCQhard

Refer to the exhibit. A ML engineer runs this Vertex AI pipeline. After execution, the "train" task fails with a resource exhaustion error. The task consumes more memory than allocated. Which step should the engineer take to fix this issue without increasing the overall quota cost?

A.Add a 'memory' field to the train task specification.
B.Configure the 'train-exec' executor to use a machine type with higher memory.
C.Increase the memory of the train task to 32 GiB.
D.Set 'acceleratorType' to 'NVIDIA_TESLA_T4' on the train task.
AnswerB

The executor defines the machine type, and modifying it to use a higher-memory machine (e.g., n1-highmem-8) will provide more memory without changing other quota.

Why this answer

In Vertex AI pipelines, memory allocation is defined at the executor level, not directly on the task. The 'train' task references the 'train-exec' executor, which specifies the machine type and thus the available memory. To resolve the resource exhaustion error without increasing overall quota cost, the engineer should change the machine type in the executor specification to a memory-optimized type (e.g., n1-highmem-*).

Options A and C are incorrect because Vertex AI pipelines do not support setting a 'memory' field directly on the task. Option D is incorrect because changing the accelerator type does not address memory exhaustion.

430
Multi-Selecteasy

Which TWO are best practices for deploying models to Vertex AI Prediction? (Choose 2.)

Select 2 answers
A.Monitor prediction latency and error rates with Cloud Monitoring alerts.
B.Log all raw prediction inputs and outputs for every request for auditing.
C.Use a dedicated service account with minimal permissions for the endpoint.
D.Always deploy the model in the same environment as training to avoid incompatibility.
E.Use the default model version alias 'default' for all deployments to simplify updates.
AnswersA, C

Essential for detecting performance issues.

Why this answer

The correct answers are A and C. Option A is a best practice because monitoring prediction latency and error rates with Cloud Monitoring alerts helps detect performance issues and ensure availability. Option C is a best practice because using a dedicated service account with minimal permissions follows the principle of least privilege, enhancing security.

Option B is not a best practice because logging all raw inputs and outputs for every request can cause privacy concerns, increase costs, and is unnecessary for most use cases. Option D is not a best practice because deploying in the same environment as training may not always be feasible; instead, models should be containerized to ensure consistency across environments. Option E is not a best practice because using the default alias 'default' for all deployments can lead to confusion and makes rollbacks more difficult; proper versioning and aliases should be used.

431
MCQhard

An ML team is using Population Stability Index (PSI) to monitor feature drift on a Vertex AI Endpoint. The PSI value for a feature is 0.25, which exceeds the alert threshold of 0.2. The feature has high SHAP importance. The team wants to automatically retrain the model. What is the correct end-to-end setup?

A.Vertex AI Model Monitoring alert → Cloud Scheduler → Vertex AI Training
B.Cloud Functions → Pub/Sub → Cloud Monitoring → Vertex AI Pipeline
C.Cloud Monitoring alert → Pub/Sub → Cloud Functions → Vertex AI Pipeline (with training and deployment steps)
D.Cloud Monitoring alert → Cloud Logging → Cloud Functions → Vertex AI Training
AnswerC

Correct: This is the recommended architecture for automated retraining.

Why this answer

The correct setup involves Cloud Monitoring alert (based on PSI metric) → Pub/Sub → Cloud Function → Vertex AI Pipeline to trigger retraining with updated data.

432
MCQhard

A company uses Vertex AI Feature Store for feature engineering. They need to ensure point-in-time correctness to avoid data leakage during training. Which feature retrieval method should they use?

A.Use the `get_features` API without specifying a timestamp.
B.Use BigQuery to manually join features with a sliding window.
C.Use the offline store with point-in-time join using the `feature_view` with a timestamp column.
D.Use the online store to retrieve the latest feature values.
AnswerC

Point-in-time join ensures correct historical context, avoiding leakage.

Why this answer

Point-in-time retrieval in Vertex AI Feature Store allows fetching feature values as they existed at a specific timestamp, preventing leakage.

433
MCQmedium

A company is deploying a new model version to an existing Vertex AI endpoint. They want to test the new version with 5% of traffic before fully rolling it out. What is the correct approach?

A.Create a new endpoint for the new version and update the client to call both endpoints.
B.Deploy the new version and set the minimum replicas to 0, then gradually increase.
C.Use Cloud Load Balancing to distribute traffic between two endpoints.
D.Deploy the new version as a separate model on the same endpoint and use the `traffic_split` parameter in the deployment request.
AnswerD

Deploying the new version as a separate model on the same Vertex AI endpoint and setting the `traffic_split` parameter to route 5% of requests to it directly satisfies the constraint of testing with a controlled fraction of live traffic before a full rollout. This mechanism uses the endpoint’s built-in traffic routing to allocate a precise percentage of inference requests to the new model version without requiring a separate endpoint or external load balancer.

Why this answer

Vertex AI endpoints support traffic splitting between multiple deployed models. By deploying the new model version to the same endpoint and setting `traffic_split` to 5% for the new version and 95% for the existing version, the endpoint automatically routes a corresponding proportion of inference requests to each model without any client-side changes.

Exam trap

The trap here is that candidates may confuse traffic splitting with scaling or load balancing, assuming that adjusting replicas or using an external load balancer is required, when Vertex AI's native `traffic_split` is the simplest and correct method for canary deployments.

How to eliminate wrong answers

Option A is wrong because creating a new endpoint and updating clients to call both endpoints introduces unnecessary complexity, latency, and risk of client misconfiguration; Vertex AI endpoints natively support traffic splitting, making this approach redundant. Option B is wrong because setting minimum replicas to 0 does not control traffic distribution; it only affects autoscaling behavior, and gradually increasing replicas does not route a specific percentage of traffic to the new version. Option C is wrong because Cloud Load Balancing operates at the network layer and cannot intelligently split traffic between two Vertex AI endpoints based on model version; it would require additional proxy logic and defeats the purpose of Vertex AI's built-in traffic management.

434
Multi-Selectmedium

An ML engineer is building a continuous training pipeline that retrains a model when new data arrives. The pipeline should also detect skew between training and serving data. Which TWO Google Cloud services should they use? (Choose two.)

Select 2 answers
A.Cloud Logging
B.Vertex AI Model Monitoring
C.Cloud Functions
D.Vertex AI Pipelines
E.Cloud Monitoring
AnswersB, D

For skew detection.

Why this answer

Vertex AI Model Monitoring (B) is correct because it is purpose-built to detect skew between training and serving data by continuously comparing feature distributions and alerting on statistically significant drift. Vertex AI Pipelines (D) is correct because it provides a serverless, scalable orchestration service for building continuous training pipelines that automatically retrain models when new data arrives, integrating with Cloud Build and other services.

Exam trap

The Google PMLE exam often tests the distinction between monitoring for infrastructure health (Cloud Monitoring) versus monitoring for ML-specific data skew (Vertex AI Model Monitoring), leading candidates to confuse general observability with ML-specific drift detection.

435
MCQmedium

A data scientist creates a custom Python function component for a Vertex AI pipeline using the Kubeflow Pipelines SDK v2. The component takes a string parameter 'input_text' and outputs a Metrics artifact. The scientist wants to include a lightweight Python function without building a container. Which code snippet correctly defines this component?

A.@dsl.component\ndef my_component(input_text: str) -> Metric:\n metrics = Metric()\n metrics.log_metric('length', len(input_text))
B.@dsl.pipeline\ndef my_pipeline(input_text: str):\n metrics = Metrics()\n metrics.log_metric('length', len(input_text))
C.def my_component(input_text: str) -> Metrics:\n from kfp.dsl import Metrics\n metrics = Metrics()\n metrics.log_metric('length', len(input_text))\n return metrics
D.@dsl.component(base_image='python:3.9')\ndef my_component(input_text: str) -> Metrics:\n from kfp.dsl import Metrics\n metrics = Metrics()\n metrics.log_metric('length', len(input_text))\n return metrics
AnswerD

Correct: Uses @dsl.component with base_image, imports Metrics inside the function, and returns a Metrics artifact.

Why this answer

It uses the `@dsl.component` decorator with a `base_image` parameter, which is required for lightweight Python function components in Kubeflow Pipelines SDK v2. The decorator enables the component to run without a custom container by specifying a base image (here, `python:3.9`), and the function correctly returns a `Metrics` artifact after logging a metric. Without the decorator or with an incorrect decorator, the component would not be recognized as a pipeline component.

Exam trap

Google often tests the requirement for the `base_image` parameter in `@dsl.component` for lightweight Python functions in Vertex AI pipelines, and candidates mistakenly assume the decorator alone is sufficient without specifying the base image.

How to eliminate wrong answers

Option A is wrong because it uses `@dsl.component` without a `base_image`, which is required for lightweight Python function components (otherwise it defaults to a container-based component, causing a runtime error). Option B is wrong because `@dsl.pipeline` is used to define a pipeline, not a component, and `Metrics()` is not a valid class (the correct class is `Metrics` from `kfp.dsl`). Option C is wrong because it lacks the `@dsl.component` decorator entirely, so the function is not registered as a pipeline component and cannot be used in a pipeline.

436
MCQhard

A hospital wants to deploy a machine learning model for detecting anomalies in patient vital signs. The model was trained on historical data but must comply with HIPAA regulations. The model serving must be low-latency (under 100 ms) and handle up to 1000 requests per second. Which architecture should they use on Google Cloud?

A.Use Vertex AI Batch Prediction to run predictions in batch jobs every hour
B.Use BigQuery ML to run predictions directly from a BigQuery table
C.Deploy the model as a container on Cloud Run with a load balancer
D.Deploy the model to Vertex AI Prediction with a private endpoint and use VPC Service Controls for data isolation
AnswerD

Vertex AI Prediction with private endpoints offers low latency and VPC-SC provides HIPAA-compliant data boundaries.

Why this answer

Vertex AI Prediction with a private endpoint and VPC Service Controls meets all requirements: it provides low-latency (sub-100ms) online predictions for up to 1000 QPS, enforces HIPAA compliance by isolating the model within a VPC and preventing data exfiltration, and supports autoscaling. Batch Prediction (A) cannot meet the latency requirement, BigQuery ML (B) is designed for analytical queries not real-time serving, and Cloud Run (C) lacks native HIPAA-compliant data isolation controls.

Exam trap

Google Cloud often tests the distinction between batch and online prediction, and candidates mistakenly choose Cloud Run because it offers low latency, but they overlook the HIPAA data isolation requirement that VPC Service Controls uniquely satisfy in a managed ML context.

How to eliminate wrong answers

Option A is wrong because Vertex AI Batch Prediction processes predictions in batch jobs with latency of minutes to hours, not sub-100ms, and cannot handle real-time requests at 1000 QPS. Option B is wrong because BigQuery ML runs predictions via SQL queries on BigQuery tables, which incurs query execution latency (typically seconds) and is not designed for low-latency online serving. Option C is wrong because Cloud Run, while capable of low-latency serving, does not provide built-in VPC Service Controls or private endpoints for HIPAA-compliant data isolation; additional configuration would be needed and it lacks the managed ML serving optimizations of Vertex AI Prediction.

437
Multi-Selecthard

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

Select 2 answers
A.Vertex AI Feature Store
B.Cloud Run
C.Vertex AI Model Registry
D.Custom container with the model and custom head
E.Pre-built container for Gemma
AnswersC, D

Required to store and deploy the model.

Why this answer

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

438
MCQhard

You are an ML engineer at a global e-commerce company. Your team has developed a deep learning model for product recommendation that runs on Vertex AI Prediction. The model is deployed on a single n1-highmem-2 instance (CPU only) with autoscaling enabled (min replicas=1, max replicas=10). During Black Friday, traffic spikes to 1000 requests per second (QPS), and you observe that latency increases from 50ms to over 5000ms, and many requests time out. You check the monitoring dashboard and see that CPU utilization is at 100% on the single instance, and autoscaling is not triggering quickly enough. The team has a budget for this service and wants to handle the spike without compromising latency. What should you do?

A.Switch to GPU instances (e.g., n1-standard-4 with T4) and set min replicas=2 with autoscaling up to 10
B.Increase min replicas to 5 to keep warm instances
C.Set min replicas=1 and max replicas=5 to control cost
D.Increase max replicas to 20 and keep CPU instances
AnswerA

GPUs accelerate inference, reducing per-request latency; warm instances handle spike.

Why this answer

Switching to GPU instances (n1-standard-4 with T4) offloads compute-intensive recommendation model inference to GPUs, significantly reducing per-request latency. Setting min replicas=2 ensures that at least two instances are always warm, reducing cold-start delays and allowing autoscaling to handle traffic spikes more responsively. This combination addresses both the CPU bottleneck and the slow scaling trigger, keeping latency under 50ms even at 1000 QPS.

Exam trap

Google Cloud often tests the misconception that simply increasing the number of CPU instances or adjusting autoscaling parameters can solve a CPU-bound latency problem, when the real fix is to change the compute architecture (e.g., GPU) to match the workload's computational profile.

How to eliminate wrong answers

Option B is wrong because increasing min replicas to 5 on CPU-only instances does not resolve the fundamental CPU bottleneck; the model still runs on CPU, so each request will still suffer high latency under load, and the cost increases without performance gain. Option C is wrong because setting max replicas to 5 limits the maximum capacity to only 5 CPU instances, which cannot handle 1000 QPS without severe latency, and min replicas=1 still risks cold-start delays. Option D is wrong because increasing max replicas to 20 on CPU instances only adds more CPU-bound nodes, which still cannot process requests fast enough per instance due to the CPU bottleneck, leading to continued high latency and timeouts.

439
MCQmedium

A startup has developed a prototype ML model using scikit-learn on a single machine. They now need to scale it to handle larger datasets and deploy it for real-time predictions. The team is small and wants minimal operational overhead. Which Google Cloud service should they use?

A.AI Platform Prediction
B.Vertex AI
C.Cloud Functions
D.Compute Engine with TensorFlow Serving
AnswerB

Vertex AI provides managed training, deployment, and autoscaling with minimal operational overhead.

Why this answer

Vertex AI (option B) is the correct choice because it provides a unified, fully managed MLOps platform that integrates model training, deployment, and scaling with minimal operational overhead. It supports scikit-learn models natively, offers auto-scaling for real-time predictions, and eliminates the need to manage infrastructure, making it ideal for a small team transitioning from a prototype.

Exam trap

Google Cloud often tests the misconception that any serverless option (like Cloud Functions) is suitable for ML inference, but the trap here is that Cloud Functions has severe resource and timeout limitations that make it impractical for real-time model serving, whereas Vertex AI is purpose-built for this workload.

How to eliminate wrong answers

Option A (AI Platform Prediction) is wrong because it is a legacy service that has been superseded by Vertex AI; while it could technically serve predictions, it lacks the unified workflow and newer features of Vertex AI, and using it would incur unnecessary complexity and potential deprecation risks. Option C (Cloud Functions) is wrong because it is a serverless compute service designed for event-driven, short-lived tasks (max 9 minutes timeout and 2 GB memory), not for hosting persistent ML models requiring real-time inference with low latency and large payloads. Option D (Compute Engine with TensorFlow Serving) is wrong because it requires manual setup, scaling, and maintenance of virtual machines, which contradicts the team's goal of minimal operational overhead; TensorFlow Serving also adds an extra layer of complexity for a scikit-learn model that could be served more simply via Vertex AI's built-in containers.

440
Multi-Selecteasy

An ML team wants to monitor their recommendation model for fairness. Which TWO metrics should they track to detect potential bias? (Select TWO.)

Select 2 answers
A.Pair-wise fairness metrics such as equal opportunity difference.
B.Recall for the minority group only.
C.Overall accuracy on the test set.
D.Average prediction confidence per request.
E.Prediction distribution (e.g., top-K recommendations) across different sensitive attribute groups.
AnswersA, E

Standard fairness metric.

Why this answer

Pair-wise fairness metrics like equal opportunity difference directly compare model outcomes (e.g., true positive rates) across sensitive groups, making them a standard tool for detecting bias in classification tasks. This metric measures the difference in true positive rates between privileged and unprivileged groups, where a value close to zero indicates fairness. Tracking such metrics aligns with the core principle of monitoring for disparate impact in ML systems.

Exam trap

Google Cloud often tests the misconception that overall accuracy or group-specific recall alone is sufficient for fairness monitoring, when in fact comparative metrics across groups are required to detect bias.

441
MCQmedium

You deploy a PyTorch model to Vertex AI Online Prediction. After deployment, you observe that inference latency is approximately 300ms per request, but the desired SLA is under 100ms. The model uses a custom container with CPU only. Which action is most likely to reduce latency to the target?

A.Deploy the model on a machine with a GPU accelerator.
B.Switch from online prediction to batch prediction.
C.Increase the min_replica_count to ensure more instances are always available.
D.Use a smaller machine type with less CPU to reduce overhead.
AnswerA

GPU can accelerate PyTorch inference significantly, reducing latency.

Why this answer

Enabling GPU acceleration can significantly speed up inference for deep learning models. Adding more CPU instances may help with throughput but not per-request latency. Switching to batch prediction changes the use case, and using a smaller instance type might reduce latency if the model is small, but GPU is more impactful.

442
MCQmedium

A team is monitoring a deployed model and notices that the prediction distribution has changed significantly over the last week. They want to detect which features are contributing most to the drift. Which tool should they use?

A.Vertex AI Explainable AI
B.Vertex AI Feature Store
C.Vertex AI Model Monitoring
D.Vertex AI Pipelines
AnswerA

Explainable AI provides feature attributions (SHAP, integrated gradients) that can help identify which features are drifting.

Why this answer

Vertex AI Explainable AI provides feature attributions (e.g., SHAP values) that can be used to identify which features are most important for predictions. By comparing feature importance over time, they can pinpoint which features are drifting.

443
MCQmedium

A company deploys a classification model on Vertex AI for loan approval. After a month, they notice the precision has dropped significantly. What should they do first?

A.Retrain the model with more data
B.Increase the number of prediction nodes
C.Check for data drift using Vertex AI Model Monitoring
D.Revert to the previous model version
AnswerC

Model monitoring is designed to detect drift, which could cause precision drop.

Why this answer

A sudden drop in precision indicates that the model's predictions are no longer aligning with the ground truth, which is a classic symptom of data drift. Vertex AI Model Monitoring can automatically detect drift in feature distributions or prediction output compared to a baseline, allowing you to identify the root cause before taking corrective action. Retraining or reverting without first diagnosing the drift could waste resources or mask the underlying issue.

Exam trap

Google Cloud often tests the misconception that any performance degradation should be immediately fixed by retraining or rolling back, rather than first diagnosing the cause through monitoring tools like Vertex AI Model Monitoring.

How to eliminate wrong answers

Option A is wrong because retraining with more data does not address the root cause if the data distribution has shifted; it may even reinforce the drift if the new data is also drifted. Option B is wrong because increasing prediction nodes only improves throughput and latency, not prediction quality or precision. Option D is wrong because reverting to a previous model version is a reactive rollback that does not diagnose why precision dropped; the old model may also suffer from drift if the environment has changed.

444
MCQmedium

A data science team uses Cloud Composer to orchestrate ML workflows. They need to trigger a Vertex AI pipeline after a BigQuery data load completes, and then run a Dataflow job. Which Airflow operator should they use to launch the Vertex AI pipeline?

A.DataflowStartFlexTemplateJobOperator
B.VertexAICreateCustomJobOperator
C.MLEngineTrainingOperator
D.VertexAIPipelineJobOperator
AnswerD

This operator triggers a Vertex AI Pipeline job within an Airflow DAG.

Why this answer

The VertexAIPipelineJobOperator is specifically designed to trigger a Vertex AI pipeline run from within an Airflow DAG. This operator directly corresponds to the requirement of launching a Vertex AI pipeline after a BigQuery data load completes, making it the appropriate choice for orchestrating ML workflows with Cloud Composer.

Exam trap

Google often tests the distinction between operators for different Vertex AI services (e.g., custom jobs vs. pipelines), so candidates may confuse VertexAICreateCustomJobOperator with VertexAIPipelineJobOperator when the question specifically asks for launching a pipeline.

How to eliminate wrong answers

Option A is wrong because DataflowStartFlexTemplateJobOperator is used to start a Dataflow job using a Flex Template, not to launch a Vertex AI pipeline. Option B is wrong because VertexAICreateCustomJobOperator is used to create a custom training job in Vertex AI, not to run a Vertex AI pipeline. Option C is wrong because MLEngineTrainingOperator is a legacy operator for AI Platform (now Vertex AI) training jobs, not for triggering Vertex AI pipelines.

445
MCQeasy

A company needs to serve a model with strict latency requirements (<100ms). They are using Vertex AI Prediction with CPU. During testing, latency is 150ms. What should they do?

A.Enable batching to improve throughput
B.Use a smaller machine type with more replicas
C.Export the model to TensorFlow Lite
D.Switch to a GPU machine type
AnswerD

GPUs can reduce inference latency.

Why this answer

The model's latency of 150ms exceeds the 100ms requirement. Switching to a GPU machine type (Option D) is correct because GPUs are optimized for parallel computation, significantly reducing inference latency for many ML models, especially deep learning models, compared to CPUs. Vertex AI Prediction supports GPU machine types, and this change directly addresses the latency bottleneck without altering the model or its serving configuration.

Exam trap

The trap here is that candidates confuse throughput optimization (batching or scaling replicas) with latency reduction, failing to recognize that GPUs directly address compute-bound latency while CPU-based solutions cannot meet strict sub-100ms requirements for complex models.

How to eliminate wrong answers

Option A is wrong because batching improves throughput (requests per second) by grouping multiple inference requests, but it typically increases per-request latency due to queuing and processing delays, making it unsuitable for a strict sub-100ms latency requirement. Option B is wrong because using a smaller machine type with more replicas can improve throughput and availability but does not reduce per-request inference latency; smaller machines often have less compute power, potentially increasing latency. Option C is wrong because exporting the model to TensorFlow Lite is designed for edge or mobile deployment with limited resources, not for optimizing latency in a cloud-based Vertex AI Prediction serving environment; it would require significant model conversion and may not be compatible with all model architectures.

446
Multi-Selectmedium

A company is implementing MLOps on Google Cloud and needs to manage model versions, assign aliases (e.g., 'champion' for production, 'challenger' for staging), store evaluation metrics alongside each model version, and deploy models to endpoints. Which service should they use? (Choose THREE that are part of the solution.)

Select 3 answers
A.Vertex AI Model Registry
B.Vertex AI Feature Store
C.Vertex AI Endpoints
D.Vertex AI Pipelines
E.Vertex AI Experiments
AnswersA, C, D

Provides model versioning, aliases (champion/challenger), and evaluation metrics storage.

Why this answer

Vertex AI Model Registry manages model versions, aliases, evaluation metrics, and deployment. Vertex AI Endpoints is the target for deployment. Vertex AI Pipelines can be used to automate the promotion and deployment process, but the question asks for the core service that provides versioning, aliases, metrics, and deployment.

Actually, the Model Registry itself handles aliases and metrics, and deployment to endpoints is done through the registry. Pipelines are optional but part of the MLOps workflow. However, the question asks for 'part of the solution' — the three key components are Model Registry, Endpoints, and Pipelines (or maybe Experiment? Let's adjust: Model Registry for versioning/aliases/metrics, Endpoints for serving, and Pipelines for automation).

Alternatively, consider that Metadata is also used for lineage. But the stem emphasizes 'manage model versions, assign aliases, store evaluation metrics, and deploy models to endpoints' — Model Registry does all that except actual deployment to endpoints (it deploys to endpoints). So the correct answer is Model Registry, Endpoints, and maybe Pipelines or Experiments.

But Experiments is not required for versioning. Given the options, the best three are: Vertex AI Model Registry (core), Vertex AI Endpoints (deployment target), and Vertex AI Pipelines (to orchestrate the deployment). However, note that Model Registry deploys to endpoints directly.

Let's choose a different combination: Model Registry, Endpoints, and maybe Metadata for lineage? But stem doesn't mention lineage. Let's stick with: Model Registry, Endpoints, and Pipelines (as a standard template). I'll keep it reasonable.

447
MCQmedium

A data scientist needs to forecast daily sales for the next 30 days using historical sales data stored in BigQuery. They want to use BigQuery ML. Which model type should they choose?

A.LINEAR_REG
B.BOOSTED_TREE_REGRESSOR
C.K_MEANS
D.ARIMA_PLUS
AnswerD

Why this answer

ARIMA_PLUS is the correct choice because it is specifically designed for time-series forecasting, such as predicting daily sales over a future horizon. BigQuery ML's ARIMA_PLUS model automatically handles seasonality, trend, and holiday effects, making it ideal for 30-day sales forecasts from historical data.

Exam trap

The trap here is that candidates often confuse regression models (like LINEAR_REG or BOOSTED_TREE_REGRESSOR) with time-series forecasting, not realizing that standard regression assumes independent observations and cannot inherently model temporal dependencies or extrapolate beyond the training period.

How to eliminate wrong answers

Option A is wrong because LINEAR_REG is a linear regression model for predicting a continuous target from input features, but it does not inherently model time-series dependencies like autocorrelation or seasonality, making it unsuitable for forecasting sequential daily sales. Option B is wrong because BOOSTED_TREE_REGRESSOR is an ensemble tree-based model for regression tasks, but it treats each row independently and cannot capture temporal patterns or extrapolate into the future without explicit feature engineering of time lags. Option C is wrong because K_MEANS is an unsupervised clustering algorithm used to partition data into groups, not for forecasting numerical values over time.

448
Multi-Selecthard

Your team is using Vertex AI Prediction for a large-scale NLP model (PyTorch, custom ops). The model currently runs on CPU but you want to optimise inference cost and performance. Which THREE approaches should you consider? (Choose 3)

Select 3 answers
A.Deploy the model with a GPU machine type and use TensorRT optimisation.
B.Use Vertex AI Model Optimisation to automatically quantise and compile the model.
C.Integrate the model with NVIDIA Triton Inference Server for dynamic batching and model ensembles.
D.Convert the model to TensorFlow Lite and deploy on Vertex AI endpoint.
E.Switch to batch prediction to reduce cost.
AnswersA, B, C

Correct. GPU and TensorRT can improve throughput and latency.

Why this answer

Deploying the model with a GPU machine type (e.g., NVIDIA A100 or T4) and using TensorRT optimization can significantly accelerate inference for PyTorch models with custom ops. TensorRT performs layer fusion, precision calibration (FP16/INT8), and kernel auto-tuning, which reduces latency and improves throughput on GPU hardware. This directly addresses the goal of optimizing both cost and performance for large-scale NLP models.

Exam trap

A common trap in Google PMLE exams is thinking that converting to a lighter framework (like TensorFlow Lite) or switching to batch prediction is a universal optimization, ignoring that custom ops and real-time latency requirements make those approaches invalid for this scenario.

449
MCQmedium

A team is monitoring a model and observes that the error rate (prediction failures) has increased. They have enabled request/response logging on the Vertex AI Endpoint. How can they set up a metric and alert for prediction error rate?

A.Configure Cloud Monitoring to pull error rate from Cloud Endpoints
B.Use Vertex AI Model Monitoring to monitor error rate directly
C.Create a log-based metric in Cloud Logging for error logs and set up an alert in Cloud Monitoring
D.Enable Vertex AI Pipelines to track errors
AnswerC

Log-based metrics are the standard way to derive metrics from logs and alert on them.

Why this answer

Vertex AI Endpoint logs contain information about failed predictions. You can create a log-based metric in Cloud Logging that counts error logs, and then create an alert in Cloud Monitoring based on that metric.

450
MCQmedium

A machine learning team wants to implement champion/challenger model deployment. They have two model versions: v1 (champion) and v2 (challenger). They deploy both to the same endpoint with traffic splitting. How should they manage model versions in Vertex AI Model Registry to reflect this?

A.Upload both models without aliases. Use endpoint traffic splitting by model version ID.
B.Upload v1 with alias 'champion' and v2 with alias 'challenger'. Then deploy both to the endpoint with traffic split.
C.Use Vertex AI Experiments to designate champion/challenger.
D.Create two separate endpoints: one for champion and one for challenger.
AnswerB

Aliases like 'champion' and 'challenger' are used to identify models and manage traffic splitting.

Why this answer

Aliases in Model Registry allow labeling models as 'champion' and 'challenger' for easy identification and traffic routing.

Page 5

Page 6 of 14

Page 7