Free Professional-Machine-Learning-Engineer Practice Test Questions and Answers (2026) | Cert Empire Practice Questions

According to the official exam guide1, one of the skills assessed in the exam is to “automate and

orchestrate ML pipelines using Cloud Composer”. Cloud Composer2 is a fully managed workflow

orchestration service that uses Apache Airflow to create, schedule, monitor, and manage workflows.

Cloud Composer allows you to build custom training pipelines for deep learning-based models and

integrate them with other Google Cloud services. You can also use Cloud Composer to implement

model interpretability techniques, such as feature attributions, explainable AI, or model debugging3.

The other options are not relevant or optimal for this scenario. Reference:

Professional ML Engineer Exam Guide

Cloud Composer

Model interpretability with Cloud Composer

Google Professional Machine Learning Certification Exam 2023

Latest Google Professional Machine Learning Engineer Actual Free Exam Questions

According to the official exam guide1, one of the skills assessed in the exam is to “track the lineage

of pipeline artifacts”. Vertex ML Metadata2 is a service that allows you to store, query, and visualize

metadata associated with your ML workflows, such as datasets, models, metrics, and executions.

Vertex ML Metadata helps you track the provenance and lineage of your ML artifacts and understand

the relationships between them. Vertex AI Experiments3 is a service that allows you to track and

compare the results of your model training runs. Vertex AI Experiments automatically logs metadata

such as hyperparameters, metrics, and artifacts for each training run. You can use Vertex AI

Experiments to train your custom model using TensorFlow, PyTorch, XGBoost, or scikit-learn. Vertex

AI TensorBoard4 is a service that allows you to visualize and monitor your ML experiments using

TensorBoard, an open source tool for ML visualization. Vertex AI TensorBoard helps you track the

model’s training parameters and the metrics per training epoch, and compare the performance of

each version of the model. Therefore, option C is the best way to determine which Vertex AI services

to include in the workflow for the given use case. The other options are not relevant or optimal for

this scenario. Reference:

Professional ML Engineer Exam Guide

Vertex ML Metadata

Vertex AI Experiments

Vertex AI TensorBoard

Google Professional Machine Learning Certification Exam 2023

Latest Google Professional Machine Learning Engineer Actual Free Exam Questions

The best option for using Vertex AI Model Monitoring for drift detection and minimizing the cost is to

use the features and the feature attributions for monitoring, and set a prediction-sampling-rate value

that is closer to 0 than 1. This option allows you to leverage the power and flexibility of Google Cloud

to detect feature drift in the input predict requests for custom models, and reduce the storage and

computation costs of the model monitoring job. Vertex AI Model Monitoring is a service that can

track and compare the results of multiple machine learning runs. Vertex AI Model Monitoring can

monitor the model’s prediction input data for feature skew and drift. Feature drift occurs when the

feature data distribution in production changes over time. If the original training data is not available,

you can enable drift detection to monitor your models for feature drift. Vertex AI Model Monitoring

uses TensorFlow Data Validation (TFDV) to calculate the distributions and distance scores for each

feature, and compares them with a baseline distribution. The baseline distribution is the statistical

distribution of the feature’s values in the training data. If the training data is not available, the

baseline distribution is calculated from the first 1000 prediction requests that the model receives. If

the distance score for a feature exceeds an alerting threshold that you set, Vertex AI Model

Monitoring sends you an email alert. However, if you use a custom model, you can also enable

feature attribution monitoring, which can provide more insights into the feature drift. Feature

attribution monitoring analyzes the feature attributions, which are the contributions of each feature

to the prediction output. Feature attribution monitoring can help you identify the features that have

the most impact on the model performance, and the features that have the most significant drift

over time. Feature attribution monitoring can also help you understand the relationship between the

features and the prediction output, and the correlation between the features1. The prediction-

sampling-rate is a parameter that determines the percentage of prediction requests that are logged

and analyzed by the model monitoring job. Using a lower prediction-sampling-rate can reduce the

storage and computation costs of the model monitoring job, but also the quality and validity of the

data. Using a lower prediction-sampling-rate can introduce sampling bias and noise into the data,

and make the model monitoring job miss some important features or patterns of the data. However,

using a higher prediction-sampling-rate can increase the storage and computation costs of the model

monitoring job, and also the amount of data that needs to be processed and analyzed. Therefore,

there is a trade-off between the prediction-sampling-rate and the cost and accuracy of the model

monitoring job, and the optimal prediction-sampling-rate depends on the business objective and the

data characteristics2. By using the features and the feature attributions for monitoring, and setting a

prediction-sampling-rate value that is closer to 0 than 1, you can use Vertex AI Model Monitoring for

drift detection and minimize the cost.

The other options are not as good as option D, for the following reasons:

Option A: Using the features for monitoring and setting a monitoring-frequency value that is higher

than the default would not enable feature attribution monitoring, and could increase the cost of the

model monitoring job. The monitoring-frequency is a parameter that determines how often the

model monitoring job analyzes the logged prediction requests and calculates the distributions and

distance scores for each feature. Using a higher monitoring-frequency can increase the frequency

and timeliness of the model monitoring job, but also the computation costs of the model monitoring

job. Moreover, using the features for monitoring would not enable feature attribution monitoring,

which can provide more insights into the feature drift and the model performance1.

Option B: Using the features for monitoring and setting a prediction-sampling-rate value that is

closer to 1 than 0 would not enable feature attribution monitoring, and could increase the cost of the

model monitoring job. The prediction-sampling-rate is a parameter that determines the percentage

of prediction requests that are logged and analyzed by the model monitoring job. Using a higher

prediction-sampling-rate can increase the quality and validity of the data, but also the storage and

computation costs of the model monitoring job. Moreover, using the features for monitoring would

not enable feature attribution monitoring, which can provide more insights into the feature drift and

the model performance12.

Option C: Using the features and the feature attributions for monitoring and setting a monitoring-

frequency value that is lower than the default would enable feature attribution monitoring, but

could reduce the frequency and timeliness of the model monitoring job. The monitoring-frequency is

a parameter that determines how often the model monitoring job analyzes the logged prediction

requests and calculates the distributions and distance scores for each feature. Using a lower

monitoring-frequency can reduce the computation costs of the model monitoring job, but also the

frequency and timeliness of the model monitoring job. This can make the model monitoring job less

responsive and effective in detecting and alerting the feature drift1.

Reference:

Preparing for Google Cloud Certification: Machine Learning Engineer, Course 3: Production ML

Systems, Week 4: Evaluation

Google Cloud Professional Machine Learning Engineer Exam Guide, Section 3: Scaling ML models in

production, 3.3 Monitoring ML models in production

Official Google Cloud Certified Professional Machine Learning Engineer Study Guide, Chapter 6:

Production ML Systems, Section 6.3: Monitoring ML Models

Using Model Monitoring

Understanding the score threshold slider

Cloud Vision API is a service that allows you to analyze images using pre-trained machine learning

models1. You can use Cloud Vision API to perform various tasks, such as face detection, text

extraction, logo recognition, and object localization1. Object localization is a feature that allows you

to detect multiple objects in an image and draw bounding boxes around them2. You can also get the

labels and confidence scores for each detected object2.

By sending user-submitted images to the Cloud Vision API, you can use object localization to identify

all objects in the image and compare the results against a list of animals. You can use

the OBJECT_LOCALIZATION feature type in the AnnotateImageRequest to request object

localization3. You can then use the localizedObjectAnnotations field in

the AnnotateImageResponse to get the list of detected objects, their labels, and their confidence

scores. You can compare the labels with a predefined list of animals, such as dogs, cats, birds, etc.,

and determine whether the image has an animal or not.

This option is the best for your scenario, because it allows you to automatically and in near real time

detect whether each uploaded photo has an animal, without requiring any manual labeling, model

training, or model deployment. You can also prioritize time and minimize cost of your application

development and deployment, as you can use the Cloud Vision API as a ready-to-use service, without

needing any machine learning expertise or infrastructure.

The other options are not suitable for your scenario, because they either require manual labeling,

model training, or model deployment, which would increase the time and cost of your application

development and deployment, or they use object detection models, which are more complex and

computationally expensive than object localization models, and are not necessary for your simple

task of detecting whether an image has an animal or not.

Reference:

Cloud Vision API | Google Cloud

Object localization | Cloud Vision API | Google Cloud

AnnotateImageRequest | Cloud Vision API | Google Cloud

[AnnotateImageResponse | Cloud Vision API | Google Cloud]

Option A is incorrect because distributing the dataset with

tf.distribute.Strategy.experimental_distribute_dataset is not the most effective way to decrease the

training time. This method allows you to distribute your dataset across multiple devices or machines,

by creating a tf.data.Dataset instance that can be iterated over in parallel1. However, this option may

not improve the training time significantly, as it does not change the amount of data or computation

that each device or machine has to process. Moreover, this option may introduce additional

overhead or complexity, as it requires you to handle the data sharding, replication, and

synchronization across the devices or machines1.

Option B is incorrect because creating a custom training loop is not the easiest way to decrease the

training time. A custom training loop is a way to implement your own logic for training your model,

by using low-level TensorFlow APIs, such as tf.GradientTape, tf.Variable, or tf.function2. A custom

training loop may give you more flexibility and control over the training process, but it also requires

more effort and expertise, as you have to write and debug the code for each step of the training loop,

such as computing the gradients, applying the optimizer, or updating the metrics2. Moreover, a

custom training loop may not improve the training time significantly, as it does not change the

amount of data or computation that each device or machine has to process.

Option C is incorrect because using a TPU with tf.distribute.TPUStrategy is not a valid way to decrease

the training time. A TPU (Tensor Processing Unit) is a custom hardware accelerator designed for high-

performance ML workloads3. A tf.distribute.TPUStrategy is a distribution strategy that allows you to

distribute your training across multiple TPUs, by creating a tf.distribute.TPUStrategy instance that can

be used with high-level TensorFlow APIs, such as Keras4. However, this option is not feasible, as

Vertex AI Training does not support TPUs as accelerators for custom training jobs5. Moreover, this

option may require significant code changes, as TPUs have different requirements and limitations

than GPUs.

Option D is correct because increasing the batch size is the best way to decrease the training time.

The batch size is a hyperparameter that determines how many samples of data are processed in each

iteration of the training loop. Increasing the batch size may reduce the training time, as it reduces the

number of iterations needed to train the model, and it allows each device or machine to process

more data in parallel. Increasing the batch size is also easy to implement, as it only requires changing

a single hyperparameter. However, increasing the batch size may also affect the convergence and the

accuracy of the model, so it is important to find the optimal batch size that balances the trade-off

between the training time and the model performance.

Reference:

tf.distribute.Strategy.experimental_distribute_dataset

Custom training loop

TPU overview

tf.distribute.TPUStrategy

Vertex AI Training accelerators

[TPU programming model]

[Batch size and learning rate]

[Keras overview]

[tf.distribute.MirroredStrategy]

[Vertex AI Training overview]

[TensorFlow overview]

A ResourceExhaustedError: out of memory (OOM) when allocating tensor is an error that occurs

when the GPU runs out of memory while trying to allocate memory for a tensor. A tensor is a multi-

dimensional array of numbers that represents the data or the parameters of a machine learning

model. The size and shape of a tensor depend on various factors, such as the input data, the model

architecture, the batch size, and the optimization algorithm1.

For the use case of training a computer vision model that predicts the type of government ID present

in a given image using a GPU-powered virtual machine on Compute Engine, the best option to

resolve the error is to reduce the batch size. The batch size is a parameter that determines how many

input examples are processed at a time by the model. A larger batch size can improve the model’s

accuracy and stability, but it also requires more memory and computation. A smaller batch size can

reduce the memory and computation requirements, but it may also affect the model’s performance

and convergence2.

By reducing the batch size, the GPU can allocate less memory for each tensor, and avoid running out

of memory. Reducing the batch size can also speed up the training process, as the GPU can process

more batches in parallel. However, reducing the batch size too much may also have some drawbacks,

such as increasing the noise and variance of the gradient updates, and slowing down the

convergence of the model. Therefore, the optimal batch size should be chosen based on the trade-off

between memory, computation, and performance3.

The other options are not as effective as option B, because they are not directly related to the

memory allocation of the GPU. Option A, changing the optimizer, may affect the speed and quality of

the optimization process, but it may not reduce the memory usage of the model. Option C, changing

the learning rate, may affect the convergence and stability of the model, but it may not reduce the

memory usage of the model. Option D, reducing the image shape, may reduce the size of the input

tensor, but it may also reduce the quality and resolution of the image, and affect the model’s

accuracy. Therefore, option B, reducing the batch size, is the best answer for this question.

Reference:

ResourceExhaustedError: OOM when allocating tensor with shape - Stack Overflow

How does batch size affect model performance and training time? - Stack Overflow

How to choose an optimal batch size for training a neural network? - Stack Overflow

Option A is incorrect because Vertex AI Pipelines and App Engine do not meet all the requirements of

the system. Vertex AI Pipelines is a service that allows you to create, run, and manage ML workflows

using TensorFlow Extended (TFX) components or custom components1. App Engine is a service that

allows you to build and deploy scalable web applications using standard or flexible

environments2. However, App Engine does not support Docker containers in the standard

environment, and does not provide a dedicated service for online prediction and monitoring of ML

models3.

Option B is correct because Vertex AI Pipelines, Vertex AI Prediction, and Vertex AI Model Monitoring

meet all the requirements of the system. Vertex AI Prediction is a service that allows you to deploy

and serve ML models for online or batch prediction, with support for autoscaling and custom

containers4. Vertex AI Model Monitoring is a service that allows you to monitor the performance and

fairness of your deployed models, and get alerts for any issues or anomalies5.

Option C is incorrect because Cloud Composer, BigQuery ML, and Vertex AI Prediction do not meet

all the requirements of the system. Cloud Composer is a service that allows you to create, schedule,

and manage workflows using Apache Airflow. BigQuery ML is a service that allows you to create and

use ML models within BigQuery using SQL queries. However, BigQuery ML does not support custom

containers, and Vertex AI Prediction does not support scheduled model retraining or model

monitoring.

Option D is incorrect because Cloud Composer, Vertex AI Training with custom containers, and App

Engine do not meet all the requirements of the system. Vertex AI Training is a service that allows you

to train ML models using built-in algorithms or custom containers. However, Vertex AI Training does

not support online prediction or model monitoring, and App Engine does not support Docker

containers in the standard environment or online prediction and monitoring of ML models3.

Reference:

Vertex AI Pipelines overview

App Engine overview

Choosing an App Engine environment

Vertex AI Prediction overview

Vertex AI Model Monitoring overview

[Cloud Composer overview]

[BigQuery ML overview]

[BigQuery ML limitations]

[Vertex AI Training overview]

According to the official exam guide1, one of the skills assessed in the exam is to “configure and

optimize model monitoring jobs”. Vertex AI Model Monitoring documentation states that “model

monitoring helps you detect when your model’s performance degrades over time due to changes in

the data that your model receives or returns” and that "you can configure model monitoring to send

notifications to Pub/Sub when it detects anomalies or drift in your model’s predictions"2. Therefore,

enabling model monitoring on the Vertex AI endpoint and configuring Pub/Sub to call the Cloud

Function when feature drift is detected would help you keep the model up-to-date and minimize

retraining costs. The other options are not relevant or optimal for this scenario. Reference:

Professional ML Engineer Exam Guide

Vertex AI Model Monitoring

Google Professional Machine Learning Certification Exam 2023

Latest Google Professional Machine Learning Engineer Actual Free Exam Questions

Kubeflow is an open source platform for developing, orchestrating, deploying, and running scalable

and portable machine learning workflows on Kubernetes. Kubeflow Pipelines is a component of

Kubeflow that allows you to build and manage end-to-end machine learning pipelines using a

graphical user interface or a Python-based domain-specific language (DSL). Kubeflow Pipelines can

help you automate and orchestrate your machine learning workflows, and integrate with various

Google Cloud services and tools1

One of the Google Cloud services that you can use with Kubeflow Pipelines is BigQuery, which is a

serverless, scalable, and cost-effective data warehouse that allows you to run fast and complex

queries on large-scale data. BigQuery can help you analyze and prepare your data for machine

learning, and store and manage your machine learning models2

To execute a query against BigQuery as the first step in your Kubeflow pipeline, and use the results of

that query as the input to the next step in your pipeline, the easiest way to do that is to use the

BigQuery Query Component, which is a pre-built component that you can find in the Kubeflow

Pipelines repository on GitHub. The BigQuery Query Component allows you to run a SQL query on

BigQuery, and output the results as a table or a file. You can use the component’s URL to load the

component into your pipeline, and specify the query and the output parameters. You can then use

the output of the component as the input to the next step in your pipeline, such as a data processing

or a model training step3

The other options are not as easy or feasible. Using the BigQuery console to execute your query and

then save the query results into a new BigQuery table is not a good idea, as it does not integrate with

your Kubeflow pipeline, and requires manual intervention and duplication of data. Writing a Python

script that uses the BigQuery API to execute queries against BigQuery is not ideal, as it requires

writing custom code and handling authentication and error handling. Using the Kubeflow Pipelines

DSL to create a custom component that uses the Python BigQuery client library to execute queries is

not optimal, as it requires creating and packaging a Docker container image for the component, and

testing and debugging the component.

Reference: 1: Kubeflow Pipelines overview 2: BigQuery overview 3: BigQuery Query Component

The most likely problem is that the tables that you created to hold your training and validation

records share some records, and you may not be using all the data in your initial table. This is

because the RAND() function generates a random number between 0 and 1 for each row, and the

probability of a row being in both the training and validation tables is 0.2 * 0.8 0.16, which is not

negligible. This means that some of the records that you use to validate your model are also used to

train your model, which can lead to overfitting and poor generalization. Moreover, the probability of

a row being in neither the training nor the validation table is 0.2 * 0.2 0.04, which means that you

are wasting some of the data in your initial table and reducing the size of your datasets. A better way

to split your data into training and validation sets is to use a hash function on a unique identifier

column, such as the following queries:

CREATE OR REPLACE TABLE ‘myproject.mydataset.training‘ AS (SELECT * FROM

‘myproject.mydataset.mytable‘ WHERE MOD(FARM_FINGERPRINT(id), 10) < 8); CREATE OR REPLACE

TABLE ‘myproject.mydataset.validation‘ AS (SELECT * FROM ‘myproject.mydataset.mytable‘ WHERE

MOD(FARM_FINGERPRINT(id), 10) > 8);

This way, you can ensure that each row has a fixed 80% chance of being in the training table and a

20% chance of being in the validation table, without any overlap or omission.

Reference:

Professional ML Engineer Exam Guide

Preparing for Google Cloud Certification: Machine Learning Engineer Professional Certificate

Google Cloud launches machine learning engineer certification

BigQuery ML: Splitting data for training and testing

BigQuery: FARM_FINGERPRINT function

Option A is incorrect because training local surrogate models to explain individual predictions is not a

feature of Vertex Explainable AI, but rather a general technique for interpreting black-box

models. Local surrogate models are simpler models that approximate the behavior of the original

model around a specific input1.

Option B is correct because configuring sampled Shapley explanations on Vertex Explainable AI is a

way to explain the difference between the actual prediction and the average prediction for a given

input. Sampled Shapley explanations are based on the Shapley value, which is a game-theoretic

concept that measures how much each feature contributes to the prediction2. Vertex Explainable AI

supports sampled Shapley explanations for tabular data, such as customer churn3.

Option C is incorrect because configuring integrated gradients explanations on Vertex Explainable AI

is not suitable for explaining the difference between the actual prediction and the average prediction

for a given input. Integrated gradients explanations are based on the idea of computing the gradients

of the prediction with respect to the input features along a path from a baseline input to the actual

input4. Vertex Explainable AI supports integrated gradients explanations for image and text data, but

not for tabular data3.

Option D is incorrect because measuring the effect of each feature as the weight of the feature

multiplied by the feature value is not a valid way to explain the difference between the actual

prediction and the average prediction for a given input. This method assumes that the model is linear

and additive, which is not the case for an ensemble of trees and neural networks. Moreover, this

method does not account for the interactions between features or the non-linearity of the model5.

Reference:

Local surrogate models

Shapley value

Vertex Explainable AI overview

Integrated gradients

Feature importance

Developing ML models with AI Platform for image segmentation on CT scans requires a lot of

computation and experimentation, as image segmentation is a complex and challenging task that

involves assigning a label to each pixel in an image. Image segmentation can be used for various

medical applications, such as tumor detection, organ segmentation, or lesion localization1

To minimize the computation costs and manual intervention while having version control for the

code, one should use Cloud Build linked with Cloud Source Repositories to trigger retraining when

new code is pushed to the repository. Cloud Build is a service that executes your builds on Google

Cloud Platform infrastructure. Cloud Build can import source code from Cloud Source Repositories,

Cloud Storage, GitHub, or Bitbucket, execute a build to your specifications, and produce artifacts

such as Docker containers or Java archives2

Cloud Build allows you to set up automated triggers that start a build when changes are pushed to a

source code repository. You can configure triggers to filter the changes based on the branch, tag, or

file path3

Cloud Source Repositories is a service that provides fully managed private Git repositories on Google

Cloud Platform. Cloud Source Repositories allows you to store, manage, and track your code using

the Git version control system. You can also use Cloud Source Repositories to connect to other

Google Cloud services, such as Cloud Build, Cloud Functions, or Cloud Run4

To use Cloud Build linked with Cloud Source Repositories to trigger retraining when new code is

pushed to the repository, you need to do the following steps:

Create a Cloud Source Repository for your code, and push your code to the repository. You can use

the Cloud SDK, Cloud Console, or Cloud Source Repositories API to create and manage your

repository5

Create a Cloud Build trigger for your repository, and specify the build configuration and the trigger

settings. You can use the Cloud SDK, Cloud Console, or Cloud Build API to create and manage your

trigger.

Specify the steps of the build in a YAML or JSON file, such as installing the dependencies, running the

tests, building the container image, and submitting the training job to AI Platform. You can also use

the Cloud Build predefined or custom build steps to simplify your build configuration.

Push your new code to the repository, and the trigger will start the build automatically. You can

monitor the status and logs of the build using the Cloud SDK, Cloud Console, or Cloud Build API.

The other options are not as easy or feasible. Using Cloud Functions to identify changes to your code

in Cloud Storage and trigger a retraining job is not ideal, as Cloud Functions has limitations on the

memory, CPU, and execution time, and does not provide a user interface for managing and tracking

your builds. Using the gcloud command-line tool to submit training jobs on AI Platform when you

update your code is not optimal, as it requires manual intervention and does not leverage the

benefits of Cloud Build and its integration with Cloud Source Repositories. Creating an automated

workflow in Cloud Composer that runs daily and looks for changes in code in Cloud Storage using a

sensor is not relevant, as Cloud Composer is mainly designed for orchestrating complex workflows

across multiple systems, and does not provide a version control system for your code.

Reference: 1: Image segmentation 2: Cloud Build overview 3: Creating and managing build

triggers 4: Cloud Source Repositories overview 5: Quickstart: Create a repository : [Quickstart: Create

a build trigger] : [Configuring builds] : [Viewing build results]

The best option for optimizing the data processing pipeline for run time and compute resources

utilization is to embed the augmentation functions dynamically in the tf.Data pipeline. This option

has the following advantages:

It allows the data augmentation to be performed on the fly, without creating or storing additional

copies of the data. This saves storage space and reduces the data transfer time.

It leverages the parallelism and performance of the tf.Data API, which can efficiently apply the

augmentation functions to multiple batches of data in parallel, using multiple CPU cores or GPU

devices. The tf.Data API also supports various optimization techniques, such as caching, prefetching,

and autotuning, to improve the data processing speed and reduce the latency.

It integrates seamlessly with the TensorFlow and Keras models, which can consume the tf.Data

datasets as inputs for training and evaluation. The tf.Data API also supports various data formats,

such as images, text, audio, and video, and various data sources, such as files, databases, and web

services.

The other options are less optimal for the following reasons:

Option B: Embedding the augmentation functions dynamically as part of Keras generators introduces

some limitations and overhead. Keras generators are Python generators that yield batches of data for

training or evaluation. However, Keras generators are not compatible with the tf.distribute API,

which is used to distribute the training across multiple devices or machines. Moreover, Keras

generators are not as efficient or scalable as the tf.Data API, as they run on a single Python thread

and do not support parallelism or optimization techniques.

Option C: Using Dataflow to create all possible augmentations, and store them as TFRecords

introduces additional complexity and cost. Dataflow is a fully managed service that runs Apache

Beam pipelines for data processing and transformation. However, using Dataflow to create all

possible augmentations requires generating and storing a large number of augmented images, which

can consume a lot of storage space and incur storage and network costs. Moreover, using Dataflow to

create the augmentations requires writing and deploying a separate Dataflow pipeline, which can be

tedious and time-consuming.

Option D: Using Dataflow to create the augmentations dynamically per training run, and stage them

as TFRecords introduces additional complexity and latency. Dataflow is a fully managed service that

runs Apache Beam pipelines for data processing and transformation. However, using Dataflow to

create the augmentations dynamically per training run requires running a Dataflow pipeline every

time the model is trained, which can introduce latency and delay the training process. Moreover,

using Dataflow to create the augmentations requires writing and deploying a separate Dataflow

pipeline, which can be tedious and time-consuming.

Reference:

[tf.data: Build TensorFlow input pipelines]

[Image augmentation | TensorFlow Core]

[Dataflow documentation]

The best option for scaling a Vertex AI endpoint efficiently when the demand increases in the future,

using a scikit-learn model that is deployed to a Vertex AI endpoint and tested on live production

traffic, is to configure an appropriate minReplicaCount value based on expected baseline traffic. This

option allows you to leverage the power and simplicity of Vertex AI to automatically scale your

endpoint resources according to the traffic patterns. Vertex AI is a unified platform for building and

deploying machine learning solutions on Google Cloud. Vertex AI can deploy a trained model to an

online prediction endpoint, which can provide low-latency predictions for individual instances.

Vertex AI can also provide various tools and services for data analysis, model development, model

deployment, model monitoring, and model governance. A minReplicaCount value is a parameter

that specifies the minimum number of replicas that the endpoint must always have, regardless of the

load. A minReplicaCount value can help you ensure that the endpoint has enough resources to

handle the expected baseline traffic, and avoid high latency or errors. By configuring an appropriate

minReplicaCount value based on expected baseline traffic, you can scale your endpoint efficiently

when the demand increases in the future. You can set the minReplicaCount value when you deploy

the model to the endpoint, or update it later. Vertex AI will automatically scale up or down the

number of replicas within the range of the minReplicaCount and maxReplicaCount values, based on

the target utilization percentage and the autoscaling metric1.

The other options are not as good as option B, for the following reasons:

Option A: Deploying two models to the same endpoint and distributing requests among them evenly

would not allow you to scale your endpoint efficiently when the demand increases in the future, and

could increase the complexity and cost of the deployment process. A model is a resource that

represents a machine learning model that you can use for prediction. A model can have one or more

versions, which are different implementations of the same model. A model version can help you

experiment and iterate on your model, and improve the model performance and accuracy. An

endpoint is a resource that provides the service endpoint (URL) you use to request the prediction. An

endpoint can have one or more deployed models, which are instances of model versions that are

associated with physical resources. A deployed model can help you serve online predictions with low

latency, and scale up or down based on the traffic. By deploying two models to the same endpoint

and distributing requests among them evenly, you can create a load balancing mechanism that can

distribute the traffic across the models, and reduce the load on each model. However, deploying two

models to the same endpoint and distributing requests among them evenly would not allow you to

scale your endpoint efficiently when the demand increases in the future, and could increase the

complexity and cost of the deployment process. You would need to write code, create and configure

the two models, deploy the models to the same endpoint, and distribute the requests among them

evenly. Moreover, this option would not use the autoscaling feature of Vertex AI, which can

automatically adjust the number of replicas based on the traffic patterns, and provide various

benefits, such as optimal resource utilization, cost savings, and performance improvement2.

Option C: Setting the target utilization percentage in the autoscalingMetricSpecs configuration to a

higher value would not allow you to scale your endpoint efficiently when the demand increases in

the future, and could cause errors or poor performance. A target utilization percentage is a

parameter that specifies the desired utilization level of each replica. A target utilization percentage

can affect the speed and accuracy of the autoscaling process. A higher target utilization percentage

can help you reduce the number of replicas, but it can also cause high latency, low throughput, or

resource exhaustion. By setting the target utilization percentage in the autoscalingMetricSpecs

configuration to a higher value, you can increase the utilization level of each replica, and save some

resources. However, setting the target utilization percentage in the autoscalingMetricSpecs

configuration to a higher value would not allow you to scale your endpoint efficiently when the

demand increases in the future, and could cause errors or poor performance. You would need to

write code, create and configure the autoscalingMetricSpecs, and set the target utilization

percentage to a higher value. Moreover, this option would not ensure that the endpoint has enough

resources to handle the expected baseline traffic, which could cause high latency or errors1.

Option D: Changing the model’s machine type to one that utilizes GPUs would not allow you to scale

your endpoint efficiently when the demand increases in the future, and could increase the

complexity and cost of the deployment process. A machine type is a parameter that specifies the

type of virtual machine that the prediction service uses for the deployed model. A machine type can

affect the speed and accuracy of the prediction process. A machine type that utilizes GPUs can help

you accelerate the computation and processing of the prediction, and handle more prediction

requests at the same time. By changing the model’s machine type to one that utilizes GPUs, you can

improve the prediction performance and efficiency of your model. However, changing the model’s

machine type to one that utilizes GPUs would not allow you to scale your endpoint efficiently when

the demand increases in the future, and could increase the complexity and cost of the deployment

process. You would need to write code, create and configure the model, deploy the model to the

endpoint, and change the machine type to one that utilizes GPUs. Moreover, this option would not

use the autoscaling feature of Vertex AI, which can automatically adjust the number of replicas based

on the traffic patterns, and provide various benefits, such as optimal resource utilization, cost

savings, and performance improvement2.

Reference:

Configure compute resources for prediction | Vertex AI | Google Cloud

Deploy a model to an endpoint | Vertex AI | Google Cloud

Option A is incorrect because it does not separate the training dataset into two tables based on the

features, which is necessary to train the two models separately and accurately.

Option B is incorrect because it does not separate the training dataset into two tables based on the

features, and because it uses the same monitoring-config-from parameter for both models, which

would not account for the different feature selections.

Option C is incorrect because it deploys the models to two separate endpoints, which would increase

the management effort and complexity of the pipeline.

Option D is correct because it separates the training dataset into two tables based on the features,

which would enable the two models to be trained separately and accurately. It also deploys both

models to the same endpoint, which would simplify the pipeline and reduce the management effort.

It also submits a Vertex Al Model Monitoring job with a monitoring-config-from parameter that

accounts for the model IDs and training datasets, which would enable the skew detection to work

properly for each model.

The best option for developing an image classification model by using a large dataset that contains

labeled images in a Cloud Storage bucket is to import the labeled images as a managed dataset in

Vertex AI and use AutoML to train the model. This option allows you to leverage the power and

simplicity of Google Cloud to create and deploy a high-quality image classification model with

minimal code and configuration. Vertex AI is a unified platform for building and deploying machine

learning solutions on Google Cloud. Vertex AI can create a managed dataset from a Cloud Storage

bucket that contains labeled images, which can be used to train an AutoML model. AutoML is a

service that can automatically build and optimize machine learning models for various tasks, such as

image classification, object detection, natural language processing, and tabular data analysis.

AutoML can handle the complex aspects of machine learning, such as feature engineering, model

architecture, hyperparameter tuning, and model evaluation. AutoML can also evaluate, deploy, and

monitor the image classification model, and provide online or batch predictions. By using Vertex AI

and AutoML, users can develop an image classification model by using a large dataset with ease and

efficiency.

The other options are not as good as option C, for the following reasons:

Option A: Using Vertex AI Pipelines with the Kubeflow Pipelines SDK to create a pipeline that reads

the images from Cloud Storage and trains the model would require more skills and steps than using

Vertex AI and AutoML. Vertex AI Pipelines is a service that can orchestrate machine learning

workflows using Vertex AI. Vertex AI Pipelines can run preprocessing and training steps on custom

Docker images, and evaluate, deploy, and monitor the machine learning model. Kubeflow Pipelines

SDK is a Python library that can create and run pipelines on Vertex AI Pipelines or on Kubeflow, an

open-source platform for machine learning on Kubernetes. However, using Vertex AI Pipelines and

Kubeflow Pipelines SDK would require writing code, building Docker images, defining pipeline

components and steps, and managing the pipeline execution and artifacts. Moreover, Vertex AI

Pipelines and Kubeflow Pipelines SDK are not specialized for image classification, and users would

need to use other libraries or frameworks, such as TensorFlow or PyTorch, to build and train the

image classification model.

Option B: Using Vertex AI Pipelines with TensorFlow Extended (TFX) to create a pipeline that reads

the images from Cloud Storage and trains the model would require more skills and steps than using

Vertex AI and AutoML. TensorFlow Extended (TFX) is a framework that can create and run end-to-end

machine learning pipelines on TensorFlow, a popular library for building and training deep learning

models. TFX can preprocess the data, train and evaluate the model, validate and push the model,

and serve the model for online or batch predictions. However, using Vertex AI Pipelines and TFX

would require writing code, building Docker images, defining pipeline components and steps, and

managing the pipeline execution and artifacts. Moreover, TFX is not optimized for image

classification, and users would need to use other libraries or tools, such as TensorFlow Data

Validation, TensorFlow Transform, and TensorFlow Hub, to handle the image data and the model

architecture.

Option D: Converting the image dataset to a tabular format using Dataflow, loading the data into

BigQuery, and using BigQuery ML to train the model would not handle the image data properly and

could result in a poor model performance. Dataflow is a service that can create scalable and reliable

pipelines to process large volumes of data from various sources. Dataflow can preprocess the data by

using Apache Beam, a programming model for defining and executing data processing workflows.

BigQuery is a serverless, scalable, and cost-effective data warehouse that can perform fast and

interactive queries on large datasets. BigQuery ML is a service that can create and train machine

learning models by using SQL queries on BigQuery. However, converting the image data to a tabular

format would lose the spatial and semantic information of the images, which are essential for image

classification. Moreover, BigQuery ML is not specialized for image classification, and users would

need to use other tools or techniques, such as feature hashing, embedding, or one-hot encoding, to

handle the categorical features.

The best option for reducing pipeline execution time and cost, while also minimizing pipeline

changes, is to enable caching for the pipeline job, and disable caching for the model training step.

This option allows you to leverage the power and simplicity of Vertex AI Pipelines to reuse the output

of the data preprocessing step, and avoid unnecessary recomputation. Vertex AI Pipelines is a service

that can orchestrate machine learning workflows using Vertex AI. Vertex AI Pipelines can run

preprocessing and training steps on custom Docker images, and evaluate, deploy, and monitor the

machine learning model. Caching is a feature of Vertex AI Pipelines that can store and reuse the

output of a pipeline step, and skip the execution of the step if the input parameters and the code

have not changed. Caching can help you reduce the pipeline execution time and cost, as you do not

need to re-run the same step with the same input and code. Caching can also help you minimize the

pipeline changes, as you do not need to add or remove any pipeline steps or parameters. By enabling

caching for the pipeline job, and disabling caching for the model training step, you can create a

Vertex AI pipeline that includes two steps. The first step preprocesses 10 TB data, completes in about

1 hour, and saves the result in a Cloud Storage bucket. The second step uses the processed data to

train a model. You can update the model’s code to allow you to test different algorithms, and run the

pipeline job with caching enabled. The pipeline job will reuse the output of the data preprocessing

step from the cache, and skip the execution of the step. The pipeline job will run the model training

step with the updated code, and disable the caching for the step. This way, you can reduce the

pipeline execution time and cost, while also minimizing pipeline changes1.

The other options are not as good as option D, for the following reasons:

Option A: Adding a pipeline parameter and an additional pipeline step, depending on the parameter

value, the pipeline step conducts or skips data preprocessing and starts model training, would

require more skills and steps than enabling caching for the pipeline job, and disabling caching for the

model training step. A pipeline parameter is a variable that can be used to control the input or

output of a pipeline step. A pipeline parameter can help you customize the pipeline logic and

behavior, and experiment with different values. An additional pipeline step is a new instance of a

pipeline component that can perform a part of the pipeline workflow, such as data preprocessing or

model training. An additional pipeline step can help you extend the pipeline functionality and

complexity, and handle different scenarios. However, adding a pipeline parameter and an additional

pipeline step, depending on the parameter value, the pipeline step conducts or skips data

preprocessing and starts model training, would require more skills and steps than enabling caching

for the pipeline job, and disabling caching for the model training step. You would need to write code,

define the pipeline parameter, create the additional pipeline step, implement the conditional logic,

and compile and run the pipeline. Moreover, this option would not reuse the output of the data

preprocessing step from the cache, but rather from the Cloud Storage bucket, which can increase the

data transfer and access costs1.

Option B: Creating another pipeline without the preprocessing step, and hardcoding the

preprocessed Cloud Storage file location for model training, would require more skills and steps than

enabling caching for the pipeline job, and disabling caching for the model training step. A pipeline

without the preprocessing step is a pipeline that only includes the model training step, and uses the

preprocessed data from the Cloud Storage bucket as the input. A pipeline without the preprocessing

step can help you avoid running the data preprocessing step every time, and reduce the pipeline

execution time and cost. However, creating another pipeline without the preprocessing step, and

hardcoding the preprocessed Cloud Storage file location for model training, would require more skills

and steps than enabling caching for the pipeline job, and disabling caching for the model training

step. You would need to write code, create a new pipeline, remove the preprocessing step, hardcode

the Cloud Storage file location, and compile and run the pipeline. Moreover, this option would not

reuse the output of the data preprocessing step from the cache, but rather from the Cloud Storage

bucket, which can increase the data transfer and access costs. Furthermore, this option would create

another pipeline, which can increase the maintenance and management costs1.

Option C: Configuring a machine with more CPU and RAM from the compute-optimized machine

family for the data preprocessing step, would not reduce the pipeline execution time and cost, while

also minimizing pipeline changes, but rather increase the pipeline execution cost and complexity. A

machine with more CPU and RAM from the compute-optimized machine family is a virtual machine

that has a high ratio of CPU cores to memory, and can provide high performance and scalability for

compute-intensive workloads. A machine with more CPU and RAM from the compute-optimized

machine family can help you optimize the data preprocessing step, and reduce the pipeline execution

time. However, configuring a machine with more CPU and RAM from the compute-optimized

machine family for the data preprocessing step, would not reduce the pipeline execution time and

cost, while also minimizing pipeline changes, but rather increase the pipeline execution cost and

complexity. You would need to write code, configure the machine type parameters for the data

preprocessing step, and compile and run the pipeline. Moreover, this option would increase the

pipeline execution cost, as machines with more CPU and RAM from the compute-optimized machine

family are more expensive than machines with less CPU and RAM from other machine

families. Furthermore, this option would not reuse the output of the data preprocessing step from

the cache, but rather re-run the data preprocessing step every time, which can increase the pipeline

execution time and cost1.

Reference:

Preparing for Google Cloud Certification: Machine Learning Engineer, Course 3: Production ML

Systems, Week 3: MLOps

Google Cloud Professional Machine Learning Engineer Exam Guide, Section 3: Scaling ML models in

production, 3.2 Automating ML workflows

Official Google Cloud Certified Professional Machine Learning Engineer Study Guide, Chapter 6:

Production ML Systems, Section 6.4: Automating ML Workflows

Vertex AI Pipelines

Caching

Pipeline parameters

Machine types

The best option for training an ML model on a large dataset, using a TPU to accelerate the training

process, and discovering that the TPU is not reaching its full capacity, is to increase the batch size.

This option allows you to leverage the power and simplicity of TPUs to train your model faster and

more efficiently. A TPU is a custom-developed application-specific integrated circuit (ASIC) that can

accelerate machine learning workloads. A TPU can provide high performance and scalability for

various types of models, such as linear regression, logistic regression, k-means clustering, matrix

factorization, and deep neural networks. A TPU can also support various tools and frameworks, such

as TensorFlow, PyTorch, and JAX. A batch size is a parameter that specifies the number of training

examples in one forward/backward pass. A batch size can affect the speed and accuracy of the

training process. A larger batch size can help you utilize the parallel processing power of the TPU, and

reduce the communication overhead between the TPU and the host CPU. A larger batch size can also

help you avoid overfitting, as it can reduce the variance of the gradient updates. By increasing the

batch size, you can train your model on a large dataset faster and more efficiently, and make full use

of the TPU capacity1.

The other options are not as good as option D, for the following reasons:

Option A: Increasing the learning rate would not help you utilize the parallel processing power of the

TPU, and could cause errors or poor performance. A learning rate is a parameter that controls how

much the model is updated in each iteration. A learning rate can affect the speed and accuracy of the

training process. A larger learning rate can help you converge faster, but it can also cause instability,

divergence, or oscillation. By increasing the learning rate, you may not be able to find the optimal

solution, and your model may perform poorly on the validation or test data2.

Option B: Increasing the number of epochs would not help you utilize the parallel processing power

of the TPU, and could increase the complexity and cost of the training process. An epoch is a measure

of the number of times all of the training examples are used once in the training process. An epoch

can affect the speed and accuracy of the training process. A larger number of epochs can help you

learn more from the data, but it can also cause overfitting, underfitting, or diminishing returns. By

increasing the number of epochs, you may not be able to improve the model performance

significantly, and your training process may take longer and consume more resources3.

Option C: Decreasing the learning rate would not help you utilize the parallel processing power of the

TPU, and could slow down the training process. A learning rate is a parameter that controls how

much the model is updated in each iteration. A learning rate can affect the speed and accuracy of the

training process. A smaller learning rate can help you find a more precise solution, but it can also

cause slow convergence or local minima. By decreasing the learning rate, you may not be able to

reach the optimal solution in a reasonable time, and your training process may take longer2.

Reference:

Preparing for Google Cloud Certification: Machine Learning Engineer, Course 2: ML Models and

Architectures, Week 1: Introduction to ML Models and Architectures

Google Cloud Professional Machine Learning Engineer Exam Guide, Section 2: Architecting ML

solutions, 2.1 Designing ML models

Official Google Cloud Certified Professional Machine Learning Engineer Study Guide, Chapter 4: ML

Models and Architectures, Section 4.1: Designing ML Models

Use TPUs

Triose phosphate utilization and beyond: from photosynthesis to end …

Cloud TPU performance guide

Google TPU: Architecture and Performance Best Practices - Run

Option A is correct because using local feature importance from the predictions is the best way to

provide the reasons that contributed to the model’s decision for a specific customer’s loan

request. Local feature importance is a measure of how much each feature affects the prediction for a

given instance, relative to the average prediction for the dataset1. AutoML Tables provides local

feature importance values for each prediction, which can be accessed using the Vertex AI SDK for

Python or the Cloud Console2. By using local feature importance, you can explain why the model

rejected the loan request based on the customer’s data.

Option B is incorrect because using the correlation with target values in the data summary page is

not a good way to provide the reasons that contributed to the model’s decision for a specific

customer’s loan request. The correlation with target values is a measure of how much each feature is

linearly related to the target variable for the entire dataset, not for a single instance3. The data

summary page in AutoML Tables shows the correlation with target values for each feature, as well as

other statistics such as mean, standard deviation, and histogram4. However, these statistics are not

useful for explaining the model’s decision for a specific customer, as they do not account for the

interactions between features or the non-linearity of the model.

Option C is incorrect because using the feature importance percentages in the model evaluation

page is not a good way to provide the reasons that contributed to the model’s decision for a specific

customer’s loan request. The feature importance percentages are a measure of how much each

feature affects the overall accuracy of the model for the entire dataset, not for a single instance5. The

model evaluation page in AutoML Tables shows the feature importance percentages for each feature,

as well as other metrics such as precision, recall, and confusion matrix. However, these metrics are

not useful for explaining the model’s decision for a specific customer, as they do not reflect the

individual contribution of each feature for a given prediction.

Option D is incorrect because varying features independently to identify the threshold per feature

that changes the classification is not a feasible way to provide the reasons that contributed to the

model’s decision for a specific customer’s loan request. This method involves changing the value of

one feature at a time, while keeping the other features constant, and observing how the prediction

changes. However, this method is not practical, as it requires making multiple prediction requests,

and may not capture the interactions between features or the non-linearity of the model.

Reference:

Local feature importance

Getting local feature importance values

Correlation with target values

Data summary page

Feature importance percentages

[Model evaluation page]

[Varying features independently]

Representation transformation (normalization) is a technique that transforms the features to be on a

similar scale, such as between 0 and 1, or with mean 0 and standard deviation 1. This technique can

improve the performance and training stability of the neural network model, as it can prevent the

gradient optimization from being dominated by features with larger scales, and help the model

converge faster and better. There are different types of normalization techniques, such as min-max

scaling, z-score scaling, log scaling, etc. You can learn more about normalization techniques from the

following web search results:

Normalization | Machine Learning | Google for Developers

NORMALIZATION TECHNIQUES IN TRAINING DNNS: METHODOLOGY, ANALYSIS AND …

Visualizing Different Normalization Techniques | by Dibya … - Medium

Data Normalization Techniques: Easy to Advanced (& the Best)