Answer: A
Explanation: The simplest and most efficient approach for preparing the data for AutoML is to use BigQuery and Vertex AI. BigQuery is a serverless, scalable, and cost-effective data warehouse that can perform fast and interactive queries on large datasets. BigQuery can preprocess the data by using SQL functions such as filtering, aggregating, joining, transforming, and creating new features. The preprocessed data can be stored in a new table in BigQuery, which can be used as the data source for Vertex AI. 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 BigQuery table, which can be used to train an AutoML model. Vertex AI can also evaluate, deploy, and monitor the AutoML model, and provide online or batch predictions. By using BigQuery and Vertex AI, users can leverage the power and simplicity of Google Cloud to train an AutoML model to predict house prices. The other options are not as simple or efficient as option A, for the following reasons: Option B: Using Dataflow to preprocess the data and write the output in TFRecord format to a Cloud Storage bucket would require more steps and resources than using BigQuery and Vertex AI. 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. TFRecord is a binary file format that can store sequential data efficiently. However, using Dataflow and TFRecord would require writing code, setting up a pipeline, choosing a runner, and managing the output files. Moreover, TFRecord is not a supported format for Vertex AI managed datasets, so the data would need to be converted to CSV or JSONL files before creating a Vertex AI managed dataset. Option C: Writing a query that preprocesses the data by using BigQuery and exporting the query results as CSV files would require more steps and storage than using BigQuery and Vertex AI. CSV is a text file format that can store tabular data in a comma-separated format. Exporting the query results as CSV files would require choosing a destination Cloud Storage bucket, specifying a file name or a wildcard, and setting the export options. Moreover, CSV files can have limitations such as size, schema, and encoding, which can affect the quality and validity of the data. Exporting the data as CSV files would also incur additional storage costs and reduce the performance of the queries. Option D: Using a Vertex AI Workbench notebook instance to preprocess the data by using the pandas library and exporting the data as CSV files would require more steps and skills than using BigQuery and Vertex AI. Vertex AI Workbench is a service that provides an integrated development environment for data science and machine learning. Vertex AI Workbench allows users to create and run Jupyter notebooks on Google Cloud, and access various tools and libraries for data analysis and machine learning. Pandas is a popular Python library that can manipulate and analyze data in a tabular format. However, using Vertex AI Workbench and pandas would require creating a notebook instance, writing Python code, installing and importing pandas, connecting to BigQuery, loading and preprocessing the data, and exporting the data as CSV files. Moreover, pandas can have limitations such as memory usage, scalability, and compatibility, which can affect the efficiency and reliability of the data processing. Reference: Preparing for Google Cloud Certification: Machine Learning Engineer, Course 2: Data Engineering for ML on Google Cloud, Week 1: Introduction to Data Engineering for ML Google Cloud Professional Machine Learning Engineer Exam Guide, Section 1: Architecting low-code ML solutions, 1.3 Training models by using AutoML Official Google Cloud Certified Professional Machine Learning Engineer Study Guide, Chapter 4: Lowcode ML Solutions, Section 4.3: AutoML BigQuery Vertex AI Dataflow TFRecord CSV Vertex AI Workbench Pandas

Answer: B
Explanation: The best option for reducing the sensitivity of the dataset before training the model is to use the Cloud Data Loss Prevention (DLP) API to scan for sensitive data, and use Dataflow with the DLP API to encrypt sensitive values with Format Preserving Encryption. This option allows you to keep every column in the dataset, while protecting the sensitive data from unauthorized access or exposure. The Cloud DLP API can detect and classify various types of sensitive data, such as names, email addresses, phone numbers, credit card numbers, and more1. Dataflow can create scalable and reliable pipelines to process large volumes of data from BigQuery and other sources2. Format Preserving Encryption (FPE) is a technique that encrypts sensitive data while preserving its original format and length, which can help maintain the utility and validity of the data3. By using Dataflow with the DLP API, you can apply FPE to the sensitive values in the dataset, and store the encrypted data in BigQuery or another destination. You can also use the same pipeline to decrypt the data when needed, by using the same encryption key and method4. The other options are not as suitable as option B, for the following reasons: Option A: Using Dataflow to ingest the columns with sensitive data from BigQuery, and then randomize the values in each sensitive column, would reduce the sensitivity of the data, but also the utility and accuracy of the data. Randomization is a technique that replaces sensitive data with random values, which can prevent re-identification of the data, but also distort the distribution and relationships of the data3. This can affect the performance and quality of the ML model, especially if every column is critical to the model. Option C: Using the Cloud DLP API to scan for sensitive data, and use Dataflow to replace all sensitive data by using the encryption algorithm AES-256 with a salt, would reduce the sensitivity of the data, but also the utility and validity of the data. AES-256 is a symmetric encryption algorithm that uses a 256-bit key to encrypt and decrypt data. A salt is a random value that is added to the data before encryption, to increase the randomness and security of the encrypted data. However, AES-256 does not preserve the format or length of the original data, which can cause problems when storing or processing the data. For example, if the original data is a 10-digit phone number, AES-256 would produce a much longer and different string, which can break the schema or logic of the dataset3. Option D: Before training, using BigQuery to select only the columns that do not contain sensitive data, and creating an authorized view of the data so that sensitive values cannot be accessed by unauthorized individuals, would reduce the exposure of the sensitive data, but also the completeness and relevance of the data. An authorized view is a BigQuery view that allows you to share query results with particular users or groups, without giving them access to the underlying tables. However, this option assumes that you can identify the columns that do not contain sensitive data, which may not be easy or accurate. Moreover, this option would remove some columns from the dataset, which can affect the performance and quality of the ML model, especially if every column is critical to the model. Reference: Preparing for Google Cloud Certification: Machine Learning Engineer, Course 5: Responsible AI, Week 2: Privacy Google Cloud Professional Machine Learning Engineer Exam Guide, Section 5: Developing responsible AI solutions, 5.2 Implementing privacy techniques Official Google Cloud Certified Professional Machine Learning Engineer Study Guide, Chapter 9: Responsible AI, Section 9.4: Privacy De-identification techniques Cloud Data Loss Prevention (DLP) API Dataflow Using Dataflow and Sensitive Data Protection to securely tokenize and import data from a relational database to BigQuery [AES encryption] [Salt (cryptography)] [Authorized views]

Answer: D
Explanation: Quantization is a technique that reduces the numerical precision of the weights and activations of a neural network, which can improve the inference speed and reduce the memory footprint of the model1. Reducing the floating point precision from tf.float64 to tf.float16 can potentially halve the latency and memory usage of the model, while having minimal impact on the accuracy2. Increasing the dropout rate to 0.8 in either mode would not affect the latency, but would likely degrade the performance of the model significantly, as dropout is a regularization technique that randomly drops out units during training to prevent overfitting3. Switching from CPU to GPU serving may or may not improve the latency, depending on the hardware specifications and the model complexity, but it would also incur additional costs and complexity for deployment4

Answer: D

Explanation:

The best option for automating the model retraining workflow is to use GitHub Actions and Cloud

Build. GitHub Actions is a service that can create and run workflows for continuous integration and

continuous delivery (CI/CD) on GitHub. GitHub Actions can run tests, build and deploy code, and

trigger other actions based on events such as code changes, pull requests, or manual triggers. Cloud

Build is a service that can create and run scalable and reliable pipelines to build, test, and deploy

software on Google Cloud. Cloud Build can build custom Docker images, push the images to Artifact

Registry, and launch the pipeline in Vertex AI Pipelines. Vertex AI Pipelines is a service that can

orchestrate machine learning (ML) workflows using Vertex AI. Vertex AI Pipelines can run

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

ML model. By using GitHub Actions and Cloud Build, users can leverage the power and flexibility of

Google Cloud to automate the model retraining workflow, while minimizing the steps required to

build the workflow.

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

Option A: Triggering a Cloud Build workflow to run tests, build custom Docker images, push the

images to Artifact Registry, and launch the pipeline in Vertex AI Pipelines would require more

configuration and maintenance than using GitHub Actions and Cloud Build. Cloud Build is a service

that can create and run pipelines to build, test, and deploy software on Google Cloud, but it is not

designed to integrate with GitHub or other source code repositories. To trigger a Cloud Build

workflow from GitHub, users would need to set up a webhook, a Cloud Pub/Sub topic, and a Cloud

Function1. Moreover, Cloud Build does not support manual triggers, which limits the flexibility of the

workflow2.

Option B: Triggering GitHub Actions to run the tests, launching a job on Cloud Run to build custom

Docker images, pushing the images to Artifact Registry, and launching the pipeline in Vertex AI

Pipelines would require more steps and resources than using GitHub Actions and Cloud Build. Cloud

Run is a service that can run stateless containers on a fully managed environment or on Anthos.

Cloud Run can build custom Docker images, but it is not optimized for this task. Users would need to

write a Dockerfile, a cloudbuild.yaml file, and a Cloud Run service configuration file, and use the

gcloud command-line tool to build and deploy the image3. Moreover, Cloud Run is designed for

serving HTTP requests, not for running ML pipelines, which can have different performance and

scalability requirements.

Option C: Triggering GitHub Actions to run the tests, building custom Docker images, pushing the

images to Artifact Registry, and launching the pipeline in Vertex AI Pipelines would require more

skills and tools than using GitHub Actions and Cloud Build. GitHub Actions can run tests and build

code, but it is not specialized for building Docker images. Users would need to install and configure

Docker on the GitHub Actions runner, write a Dockerfile, and use the docker command-line tool to

build and push the image. Moreover, GitHub Actions has limitations on the disk space, memory, and

CPU of the runner, which can affect the speed and reliability of the image building process.

Reference:

Building CI/CD for Vertex AI pipelines: The first solution

Cloud Build

GitHub Actions

Vertex AI Pipelines

Triggering builds from GitHub

Triggering builds manually

Building containers

Cloud Run

Answer: C
Explanation: The best option for analyzing large and complex datasets while minimizing computational resources is to use a combination of BigQuery and Vertex AI Workbench. BigQuery is a serverless, scalable, and cost-effective data warehouse that can perform fast and interactive queries on petabytes of data. BigQuery can calculate descriptive statistics such as mean, median, and mode by using SQL functions such as AVG, PERCENTILE_CONT, and MODE. Vertex AI Workbench is a managed service that provides an integrated development environment for data science and machine learning. Vertex AI Workbench allows users to create and run Jupyter notebooks on Google Cloud, and access various tools and libraries for data visualization and statistical analysis. Vertex AI Workbench can connect to BigQuery and use the results of the queries to create time plots and run statistical tests for hypothesis testing. By using BigQuery and Vertex AI Workbench, users can leverage the power and flexibility of Google Cloud to perform exploratory data analysis on large and complex datasets. Reference: Preparing for Google Cloud Certification: Machine Learning Engineer, Course 2: Data Engineering for ML on Google Cloud, Week 1: Introduction to Data Engineering for ML Google Cloud Professional Machine Learning Engineer Exam Guide, Section 1: Architecting low-code ML solutions, 1.1 Developing ML models by using BigQuery ML Official Google Cloud Certified Professional Machine Learning Engineer Study Guide, Chapter 3: Data Engineering for ML, Section 3.2: BigQuery for ML

Answer: A
Explanation: The problem of the text classifier is that it has a high false positive rate for comments that reference certain underrepresented religious groups. This means that the classifier is not able to distinguish between toxic and non-toxic language when those groups are mentioned. One possible reason for this is that the training data does not have enough examples of non-toxic comments that reference those groups, leading to a biased model. Therefore, a possible solution is to add synthetic training data where those phrases are used in non-toxic ways, which can help the model learn to generalize better and reduce the false positive rate. Synthetic data is artificially generated data that mimics the characteristics of real data, and can be used to augment the existing data when the real data is scarce or imbalanced. Reference: Preparing for Google Cloud Certification: Machine Learning Engineer, Course 5: Responsible AI, Week 3: Fairness Google Cloud Professional Machine Learning Engineer Exam Guide, Section 4: Ensuring solution quality, 4.4 Evaluating fairness and bias in ML models Official Google Cloud Certified Professional Machine Learning Engineer Study Guide, Chapter 9: Responsible AI, Section 9.3: Fairness and Bias

Answer: A

Explanation:

The best option for building an ML model to predict customer purchase behavior in BigQuery ML is to

use the transform clause with the ML.ONE_HOT_ENCODER function on the categorical features at

model creation and select the categorical and non-categorical features. This option allows you to

encode the categorical features as one-hot vectors, which are binary vectors that have only one nonzero

element. One-hot encoding is a common technique for handling categorical features in ML

models, as it can reduce the dimensionality and sparsity of the data, and avoid the ordinality

problem that arises when using numerical labels for categorical values1. The transform clause is a

feature of BigQuery ML that lets you apply SQL expressions to transform the input data at model

creation time. The transform clause can perform feature engineering, such as one-hot encoding, on

the fly, without requiring you to create and store a new table with the transformed data2. By using

the transform clause with the ML.ONE_HOT_ENCODER function, you can create and train an ML

model in BigQuery ML with a single SQL statement, and export it to Cloud Storage for online

prediction.

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

Option B: Using the ML.ONE_HOT_ENCODER function on the categorical features, and selecting the

encoded categorical features and non-categorical features as inputs to create your model, would

require more steps and storage than using the transform clause. The ML.ONE_HOT_ENCODER

function is a BigQuery ML function that returns a one-hot encoded vector for a given categorical

value. However, using this function alone would not apply the one-hot encoding to the input data at

model creation time. You would need to create a new table with the encoded features, and use that

table as the input to create your model. This would incur additional storage costs and reduce the

performance of the queries.

Option C: Using the create model statement and selecting the categorical and non-categorical

features, would not handle the categorical features properly and could result in a poor model

performance. The create model statement is a BigQuery ML statement that creates and trains an ML

model from a SQL query. However, if the input data contains categorical features, you need to

encode them as one-hot vectors or use the category_count option to specify the number of

categories for each feature. Otherwise, BigQuery ML would treat the categorical features as

numerical values, which can introduce bias and noise into the model3.

Option D: Using the ML.ONE_HOT_ENCODER function on the categorical features, and selecting the

encoded categorical features and non-categorical features as inputs to create your model, is the

same as option B, and has the same drawbacks.

Reference:

Preparing for Google Cloud Certification: Machine Learning Engineer, Course 2: Data Engineering for

ML on Google Cloud, Week 2: Feature Engineering

Google Cloud Professional Machine Learning Engineer Exam Guide, Section 1: Architecting low-code

ML solutions, 1.1 Developing ML models by using BigQuery ML

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

Engineering for ML, Section 3.2: BigQuery for ML

One-hot encoding

Using the TRANSFORM clause for feature engineering

Creating a model

ML.ONE_HOT_ENCODER function

Answer: C
Explanation: The best option for choosing a model that prioritizes detection while ensuring that more than 50% of the maintenance jobs triggered by the model address an imminent machine failure is to choose the model with the highest recall where precision is greater than 0.5. This option has the following advantages: It maximizes the recall, which is the proportion of actual failures that are correctly predicted by the model. Recall is also known as sensitivity or true positive rate (TPR), and it is calculated as: mathrmRecall=fracmathrmTPmathrmTP+mathrmFN where TP is the number of true positives (actual failures that are predicted as failures) and FN is the number of false negatives (actual failures that are predicted as non-failures). By maximizing the recall, the model can reduce the number of false negatives, which are the most costly and undesirable outcomes for the predictive maintenance use case, as they represent missed failures that can lead to machine breakdown and downtime. It constrains the precision, which is the proportion of predicted failures that are actual failures. Precision is also known as positive predictive value (PPV), and it is calculated as: mathrmPrecision=fracmathrmTPmathrmTP+mathrmFP where FP is the number of false positives (actual non-failures that are predicted as failures). By constraining the precision to be greater than 0.5, the model can ensure that more than 50% of the maintenance jobs triggered by the model address an imminent machine failure, which can avoid unnecessary or wasteful maintenance costs. The other options are less optimal for the following reasons: Option A: Choosing the model with the highest area under the receiver operating characteristic curve (AUC ROC) and precision greater than 0.5 may not prioritize detection, as the AUC ROC does not directly measure the recall. The AUC ROC is a summary metric that evaluates the overall performance of a binary classifier across all possible thresholds. The ROC curve plots the TPR (recall) against the false positive rate (FPR), which is the proportion of actual non-failures that are incorrectly predicted by the model. The AUC ROC is the area under the ROC curve, and it ranges from 0 to 1, where 1 represents a perfect classifier. However, choosing the model with the highest AUC ROC may not maximize the recall, as the AUC ROC is influenced by both the TPR and the FPR, and it does not account for the precision or the specificity (the proportion of actual non-failures that are correctly predicted by the model). Option B: Choosing the model with the lowest root mean squared error (RMSE) and recall greater than 0.5 may not prioritize detection, as the RMSE is not a suitable metric for binary classification. The RMSE is a regression metric that measures the average magnitude of the error between the predicted and the actual values. The RMSE is calculated as: mathrmRMSE=sqrtfrac1nsumi=1n (yi âˆ’hatyi )2 where yi is the actual value, hatyi is the predicted value, and n is the number of observations. However, choosing the model with the lowest RMSE may not optimize the detection of failures, as the RMSE is sensitive to outliers and does not account for the class imbalance or the cost of misclassification. Option D: Choosing the model with the highest precision where recall is greater than 0.5 may not prioritize detection, as the precision may not be the most important metric for the predictive maintenance use case. The precision measures the accuracy of the positive predictions, but it does not reflect the sensitivity or the coverage of the model. By choosing the model with the highest precision, the model may sacrifice the recall, which is the proportion of actual failures that are correctly predicted by the model. This may increase the number of false negatives, which are the most costly and undesirable outcomes for the predictive maintenance use case, as they represent missed failures that can lead to machine breakdown and downtime. Reference: Evaluation Metrics (Classifiers) - Stanford University Evaluation of binary classifiers - Wikipedia Predictive Maintenance: The greatest benefits and smart use cases

Answer: C

Explanation:

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.

Answer: B
Explanation: The best option for scaling the training workload while minimizing cost is to package the code with Setuptools, and use a pre-built container. Train the model with Vertex AI using a custom tier that contains the required GPUs. This option has the following advantages: It allows the code to be easily packaged and deployed, as Setuptools is a Python tool that helps to create and distribute Python packages, and pre-built containers are Docker images that contain all the dependencies and libraries needed to run the code. By packaging the code with Setuptools, and using a pre-built container, you can avoid the hassle and complexity of building and maintaining your own custom container, and ensure the compatibility and portability of your code across different environments. It leverages the scalability and performance of Vertex AI, which is a fully managed service that provides various tools and features for machine learning, such as training, tuning, serving, and monitoring. By training the model with Vertex AI, you can take advantage of the distributed and parallel training capabilities of Vertex AI, which can speed up the training process and improve the model quality. Vertex AI also supports various frameworks and models, such as PyTorch and ResNet50, and allows you to use custom containers and custom tiers to customize your training configuration and resources. It reduces the cost and complexity of the training process, as Vertex AI allows you to use a custom tier that contains the required GPUs, which can optimize the resource utilization and allocation for your training job. By using a custom tier that contains 4 V100 GPUs, you can match the number and type of GPUs that you plan to use for your training job, and avoid paying for unnecessary or underutilized resources. Vertex AI also offers various pricing options and discounts, such as persecond billing, sustained use discounts, and preemptible VMs, that can lower the cost of the training process. The other options are less optimal for the following reasons: Option A: Configuring a Compute Engine VM with all the dependencies that launches the training. Train the model with Vertex AI using a custom tier that contains the required GPUs, introduces additional complexity and overhead. This option requires creating and managing a Compute Engine VM, which is a virtual machine that runs on Google Cloud. However, using a Compute Engine VM to launch the training may not be necessary or efficient, as it requires installing and configuring all the dependencies and libraries needed to run the code, and maintaining and updating the VM. Moreover, using a Compute Engine VM to launch the training may incur additional cost and latency, as it requires paying for the VM usage and transferring the data and the code between the VM and Vertex AI. Option C: Creating a Vertex AI Workbench user-managed notebooks instance with 4 V100 GPUs, and using it to train the model, introduces additional cost and risk. This option requires creating and managing a Vertex AI Workbench user-managed notebooks instance, which is a service that allows you to create and run Jupyter notebooks on Google Cloud. However, using a Vertex AI Workbench user-managed notebooks instance to train the model may not be optimal or secure, as it requires paying for the notebooks instance usage, which can be expensive and wasteful, especially if the notebooks instance is not used for other purposes. Moreover, using a Vertex AI Workbench usermanaged notebooks instance to train the model may expose the model and the data to potential security or privacy issues, as the notebooks instance is not fully managed by Google Cloud, and may be accessed or modified by unauthorized users or malicious actors. Option D: Creating a Google Kubernetes Engine cluster with a node pool that has 4 V100 GPUs. Prepare and submit a TFJob operator to this node pool, introduces additional complexity and cost. This option requires creating and managing a Google Kubernetes Engine cluster, which is a fully managed service that runs Kubernetes clusters on Google Cloud. Moreover, this option requires creating and managing a node pool that has 4 V100 GPUs, which is a group of nodes that share the same configuration and resources. Furthermore, this option requires preparing and submitting a TFJob operator to this node pool, which is a Kubernetes custom resource that defines a TensorFlow training job. However, using Google Kubernetes Engine, node pool, and TFJob operator to train the model may not be necessary or efficient, as it requires configuring and maintaining the cluster, the node pool, and the TFJob operator, and paying for their usage. Moreover, using Google Kubernetes Engine, node pool, and TFJob operator to train the model may not be compatible or scalable, as they are designed for TensorFlow models, not PyTorch models, and may not support distributed or parallel training. Reference: [Vertex AI: Training with custom containers] [Vertex AI: Using custom machine types] [Setuptools documentation] [PyTorch documentation] [ResNet50 | PyTorch]

Answer: B, C

Explanation:

The best options for adjusting the training parameters in AutoML to improve model performance are

to decrease the score threshold and add more positive examples to the training set. These options

can help increase the detection rate of fraudulent transactions, which is the priority for this use case.

The score threshold is a parameter that determines the minimum probability score that a prediction

must have to be classified as positive. Decreasing the score threshold can increase the recall of the

model, which is the proportion of actual positive cases that are correctly identified. Increasing the

recall can help reduce the number of false negatives, which are fraudulent transactions that are

missed by the model. However, decreasing the score threshold can also decrease the precision of the

model, which is the proportion of positive predictions that are actually correct. Decreasing the

precision can increase the number of false positives, which are legitimate transactions that are

flagged as fraudulent by the model. Therefore, there is a trade-off between recall and precision, and

the optimal score threshold depends on the business objective and the cost of errors1. Adding more

positive examples to the training set can help balance the data distribution and improve the model

performance. Positive examples are the instances that belong to the target class, which in this case

are fraudulent transactions. Negative examples are the instances that belong to the other class,

which in this case are legitimate transactions. Fraudulent transactions are usually rare and

imbalanced compared to legitimate transactions, which can cause the model to be biased towards

the majority class and fail to learn the characteristics of the minority class. Adding more positive

examples can help the model learn more features and patterns of the fraudulent transactions, and

increase the detection rate2.

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

Option A: Increasing the score threshold would decrease the detection rate of fraudulent

transactions, which is the opposite of the desired outcome. Increasing the score threshold would

decrease the recall of the model, which is the proportion of actual positive cases that are correctly

identified. Decreasing the recall would increase the number of false negatives, which are fraudulent

transactions that are missed by the model. Increasing the score threshold would increase the

precision of the model, which is the proportion of positive predictions that are actually correct.

Increasing the precision would decrease the number of false positives, which are legitimate

transactions that are flagged as fraudulent by the model. However, in this use case, the cost of false

negatives is much higher than the cost of false positives, so increasing the score threshold is not a

good option1.

Option D: Adding more negative examples to the training set would not improve the model

performance, and could worsen the data imbalance. Negative examples are the instances that

belong to the other class, which in this case are legitimate transactions. Legitimate transactions are

usually abundant and dominant compared to fraudulent transactions, which can cause the model to

be biased towards the majority class and fail to learn the characteristics of the minority class. Adding

more negative examples would exacerbate this problem, and decrease the detection rate of the

fraudulent transactions2.

Option E: Reducing the maximum number of node hours for training would not improve the model

performance, and could limit the model optimization. Node hours are the units of computation that

are used to train an AutoML model. The maximum number of node hours is a parameter that

determines the upper limit of node hours that can be used for training. Reducing the maximum

number of node hours would reduce the training time and cost, but also the model quality and

accuracy. Reducing the maximum number of node hours would limit the number of iterations, trials,

and evaluations that the model can perform, and prevent the model from finding the optimal

hyperparameters and architecture3.

Reference:

Preparing for Google Cloud Certification: Machine Learning Engineer, Course 5: Responsible AI,

Week 4: Evaluation

Google Cloud Professional Machine Learning Engineer Exam Guide, Section 2: Developing highquality

ML models, 2.2 Handling imbalanced data

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

ML Solutions, Section 4.3: AutoML

Understanding the score threshold slider

Handling imbalanced data sets in machine learning

AutoML Vision pricing

Answer: C
Explanation: The best option for dealing with the missing categorical variable in the test set is to apply one-hot encoding on the categorical variables in the test data. This option has the following advantages: It ensures the consistency and compatibility of the data format for the ML model, as the one-hot encoding transforms the categorical variables into binary vectors that can be easily processed by the model. By applying one-hot encoding on the categorical variables in the test data, you can match the number and order of the features in the test data with the training data, and avoid any errors or discrepancies in the model prediction. It preserves the information and relevance of the data for the ML model, as the one-hot encoding creates a separate feature for each possible value of the categorical variable, and assigns a value of 1 to the feature corresponding to the actual value of the variable, and 0 to the rest. By applying onehot encoding on the categorical variables in the test data, you can retain the original meaning and importance of the categorical variable, and avoid any loss or distortion of the data. The other options are less optimal for the following reasons: Option A: Randomly redistributing the data, with 70% for the training set and 30% for the test set, introduces additional complexity and risk. This option requires reshuffling and splitting the data again, which can be tedious and time-consuming. Moreover, this option may not guarantee that the missing categorical variable will be present in the test set, as it depends on the randomness of the data distribution. Furthermore, this option may affect the quality and validity of the ML model, as it may change the data characteristics and patterns that the model has learned from the original training set. Option B: Using sparse representation in the test set introduces additional overhead and inefficiency. This option requires converting the categorical variables in the test set into sparse vectors, which are vectors that have mostly zero values and only store the indices and values of the non-zero elements. However, using sparse representation in the test set may not be compatible with the ML model, as the model expects the input data to have the same format and dimensionality as the training data, which uses one-hot encoding. Moreover, using sparse representation in the test set may not be efficient or scalable, as it requires additional computation and memory to store and process the sparse vectors. Option D: Collecting more data representing all categories introduces additional cost and delay. This option requires obtaining and labeling more data that contains the missing categorical variable, which can be expensive and time-consuming. Moreover, this option may not be feasible or necessary, as the missing categorical variable may not be available or relevant for the test data, depending on the data source or the business problem.

Answer: C
Explanation: The best option for parametrizing the model training in Kubeflow Pipelines is to add a ContainerOp to the pipeline that spins a Dataproc cluster, runs a transformation, and then saves the transformed data in Cloud Storage. This option has the following advantages: It allows the data transformation to be performed as part of the Kubeflow Pipeline, which can ensure the consistency and reproducibility of the data processing and the model training. By adding a ContainerOp to the pipeline, you can define the parameters and the logic of the data transformation step, and integrate it with the other steps of the pipeline, such as the model training and evaluation. It leverages the scalability and performance of Dataproc, which is a fully managed service that runs Apache Spark and Apache Hadoop clusters on Google Cloud. By spinning a Dataproc cluster, you can run the PySpark transformation on the Parquet files stored in the Hive table, and take advantage of the parallelism and speed of Spark. Dataproc also supports various features and integrations, such as autoscaling, preemptible VMs, and connectors to other Google Cloud services, that can optimize the data processing and reduce the cost. It simplifies the data storage and access, as the transformed data is saved in Cloud Storage, which is a scalable, durable, and secure object storage service. By saving the transformed data in Cloud Storage, you can avoid the overhead and complexity of managing the data in the Hive table or the Parquet files. Moreover, you can easily access the transformed data from Cloud Storage, using various tools and frameworks, such as TensorFlow, BigQuery, or Vertex AI. The other options are less optimal for the following reasons: Option A: Removing the data transformation step from the pipeline eliminates the parametrization of the model training, as the data processing and the model training are decoupled and independent. This option requires running the PySpark transformation separately from the Kubeflow Pipeline, which can introduce inconsistency and unreproducibility in the data processing and the model training. Moreover, this option requires managing the data in the Hive table or the Parquet files, which can be cumbersome and inefficient. Option B: Containerizing the PySpark transformation step, and adding it to the pipeline introduces additional complexity and overhead. This option requires creating and maintaining a Docker image that can run the PySpark transformation, which can be challenging and time-consuming. Moreover, this option requires running the PySpark transformation on a single container, which can be slow and inefficient, as it does not leverage the parallelism and performance of Spark. Option D: Deploying Apache Spark at a separate node pool in a Google Kubernetes Engine cluster, and adding a ContainerOp to the pipeline that invokes a corresponding transformation job for this Spark instance introduces additional complexity and cost. This option requires creating and managing a separate node pool in a Google Kubernetes Engine cluster, which is a fully managed service that runs Kubernetes clusters on Google Cloud. Moreover, this option requires deploying and running Apache Spark on the node pool, which can be tedious and costly, as it requires configuring and maintaining the Spark cluster, and paying for the node pool usage.

Answer: B
Explanation: This is not a good result because the model is performing worse than predicting that people will always renew their subscription. This option has the following reasons: It indicates that the model is not learning from the data, but rather memorizing the majority class. Since 90% of the individuals renew their subscription every year, the model can achieve a 90% accuracy by simply predicting that everyone will renew their subscription, without considering the features or the patterns in the data. However, the models accuracy for predicting those who renew their subscription is only 82%, which is lower than the baseline accuracy of 90%. This suggests that the model is overfitting to the minority class (those who cancel their subscription), and underfitting to the majority class (those who renew their subscription). It implies that the model is not useful for the business problem, as it cannot identify the customers who are at risk of churning. The goal of predicting whether customers will cancel their annual subscription is to prevent customer churn and increase customer retention. However, the models accuracy for predicting those who cancel their subscription is 99%, which is too high and unrealistic, as it means that the model can almost perfectly identify the customers who will churn, without any false positives or false negatives. This may indicate that the model is cheating or exploiting some leakage in the data, such as a feature that reveals the outcome of the prediction. Moreover, the models accuracy for predicting those who renew their subscription is 82%, which is too low and unreliable, as it means that the model can miss many customers who will churn, and falsely label them as renewing customers. This can lead to losing customers and revenue, and failing to take proactive actions to retain them. Reference: How to Evaluate Machine Learning Models: Classification Metrics | Machine Learning Mastery Imbalanced Classification: Predicting Subscription Churn | Machine Learning Mastery

Answer: C
Explanation: The best option for protecting sensitive customer data that might be used in the ML models is to coarsen the data by putting AGE into quantiles and rounding LATITUDE_LONGITUDE into single precision. This option has the following advantages: It preserves the utility and relevance of the data for the ML models, as the coarsened data still captures the essential information and patterns that the models need to learn. For example, putting AGE into quantiles can group the customers into different age ranges, which can be useful for predicting their preferences or behavior. Rounding LATITUDE_LONGITUDE into single precision can reduce the precision of the location data, but still retain the general geographic region of the customers, which can be useful for personalizing the recommendations or offers. It reduces the risk of exposing the personal or private information of the customers, as the coarsened data makes it harder to identify or re-identify the individual customers from the data. For example, putting AGE into quantiles can hide the exact age of the customers, which can be considered sensitive or confidential. Rounding LATITUDE_LONGITUDE into single precision can obscure the exact location of the customers, which can be considered sensitive or confidential. The other options are less optimal for the following reasons: Option A: Tokenizing all of the fields using hashed dummy values to replace the real values eliminates the utility and relevance of the data for the ML models, as the tokenized data loses all the information and patterns that the models need to learn. For example, tokenizing AGE using hashed dummy values can make the data meaningless and irrelevant, as the models cannot learn anything from the random tokens. Tokenizing LATITUDE_LONGITUDE using hashed dummy values can make the data meaningless and irrelevant, as the models cannot learn anything from the random tokens. Option B: Using principal component analysis (PCA) to reduce the four sensitive fields to one PCA vector reduces the utility and relevance of the data for the ML models, as the PCA vector may not capture all the information and patterns that the models need to learn. For example, using PCA to reduce AGE, IS_EXISTING_CUSTOMER, LATITUDE_LONGITUDE, and SHIRT_SIZE to one PCA vector can lose some information or introduce noise in the data, as the PCA vector is a linear combination of the original features, which may not reflect their true relationship or importance. Moreover, using PCA to reduce the four sensitive fields to one PCA vector may not reduce the risk of exposing the personal or private information of the customers, as the PCA vector may still be reversible or linkable to the original data, depending on the amount of variance explained by the PCA vector and the availability of the PCA transformation matrix. Option D: Removing all sensitive data fields, and asking the data science team to build their models using non-sensitive data reduces the utility and relevance of the data for the ML models, as the nonsensitive data may not contain enough information and patterns that the models need to learn. For example, removing AGE, IS_EXISTING_CUSTOMER, LATITUDE_LONGITUDE, and SHIRT_SIZE from the data can make the data insufficient and unrepresentative, as the models may not be able to learn the factors that influence the customers preferences or behavior. Moreover, removing all sensitive data fields from the data may not be necessary or feasible, as the data protection legislation may allow the use of sensitive data for the ML models, as long as the data is processed in a secure and ethical manner, and the customers consent and rights are respected. Reference: Protecting Sensitive Data and AI Models with Confidential Computing | NVIDIA Technical Blog Training machine learning models from sensitive data | Fast Data Science Securing ML applications. Model security and protection - Medium Security of AI/ML systems, ML model security | Cossack Labs Vulnerabilities, security and privacy for machine learning models

Answer: B
Explanation: The simplest way to deploy a logistic regression model with BigQuery ML to production while adding minimal latency is to export the model in TensorFlow format, and add a tfx_bsl.public.beam.RunInference step to the Dataflow pipeline. This option has the following advantages: It allows the model prediction to be performed in real time, as part of the Dataflow streaming pipeline that processes the ticket purchase requests. This ensures that the promo code offer is based on the most recent data and customer behavior, and that the offer is delivered to the customer without delay. It leverages the compatibility and performance of TensorFlow and Dataflow, which are both part of the Google Cloud ecosystem. TensorFlow is a popular and powerful framework for building and deploying machine learning models, and Dataflow is a fully managed service that runs Apache Beam pipelines for data processing and transformation. By using the tfx_bsl.public.beam.RunInference step, you can easily integrate your TensorFlow model with your Dataflow pipeline, and take advantage of the parallelism and scalability of Dataflow. It simplifies the model deployment and management, as the model is packaged with the Dataflow pipeline and does not require a separate service or endpoint. The model can be updated by redeploying the Dataflow pipeline with a new model version. The other options are less optimal for the following reasons: Option A: Running batch inference with BigQuery ML every five minutes on each new set of tickets issued introduces additional latency and complexity. This option requires running a separate BigQuery job every five minutes, which can incur network overhead and latency. Moreover, this option requires storing and retrieving the intermediate results of the batch inference, which can consume storage space and increase the data transfer time. Option C: Exporting the model in TensorFlow format, deploying it on Vertex AI, and querying the prediction endpoint from the streaming pipeline introduces additional latency and cost. This option requires creating and managing a Vertex AI endpoint, which is a managed service that provides various tools and features for machine learning, such as training, tuning, serving, and monitoring. However, querying the Vertex AI endpoint from the streaming pipeline requires making an HTTP request, which can incur network overhead and latency. Moreover, this option requires paying for the Vertex AI endpoint usage, which can increase the cost of the model deployment. Option D: Converting the model with TensorFlow Lite (TFLite), and adding it to the mobile app so that the promo code and the incoming request arrive together in Pub/Sub introduces additional challenges and risks. This option requires converting the model to a TFLite format, which is a lightweight and optimized format for running TensorFlow models on mobile and embedded devices. However, converting the model to TFLite may not preserve the accuracy or functionality of the original model, as some operations or features may not be supported by TFLite. Moreover, this option requires updating the mobile app with the TFLite model, which can be tedious and timeconsuming, and may depend on the users willingness to update the app. Additionally, this option may expose the model to potential security or privacy issues, as the model is running on the users device and may be accessed or modified by malicious actors. Reference: [Exporting models for prediction | BigQuery ML] [tfx_bsl.public.beam.run_inference | TensorFlow Extended] [Vertex AI documentation] [TensorFlow Lite documentation]

Answer: D
Explanation: The best option for determining how often to retrain your model to maintain a high level of performance while minimizing cost is to run training-serving skew detection batch jobs every few days. Training-serving skew refers to the discrepancy between the distributions of the features in the training dataset and the serving data. This can cause the model to perform poorly on the new data, as it is not representative of the data that the model was trained on. By running training-serving skew detection batch jobs, you can monitor the changes in the feature distributions over time, and identify when the skew becomes significant enough to affect the model performance. If skew is detected, you can send the most recent serving data to the labeling service, and use the labeled data to retrain your model. This option has the following benefits: It allows you to retrain your model only when necessary, based on the actual data changes, rather than on a fixed schedule or a heuristic. This can save you the cost of the labeling service and the retraining process, and also avoid overfitting or underfitting your model. It leverages the existing tools and frameworks for training-serving skew detection, such as TensorFlow Data Validation (TFDV) and Vertex Data Labeling. TFDV is a library that can compute and visualize descriptive statistics for your datasets, and compare the statistics across different datasets. Vertex Data Labeling is a service that can label your data with high quality and low latency, using either human labelers or automated labelers. It integrates well with the MLOps practices, such as continuous integration and continuous delivery (CI/CD), which can automate the workflow of running the skew detection jobs, sending the data to the labeling service, retraining the model, and deploying the new model version. The other options are less optimal for the following reasons: Option A: Training an anomaly detection model on the training dataset, and running all incoming requests through this model, introduces additional complexity and overhead. This option requires building and maintaining a separate model for anomaly detection, which can be challenging and time-consuming. Moreover, this option requires running the anomaly detection model on every request, which can increase the latency and resource consumption of the prediction service. Additionally, this option may not capture the subtle changes in the feature distributions that can affect the model performance, as anomalies are usually defined as rare or extreme events. Option B: Identifying temporal patterns in your models performance over the previous year, and creating a schedule for sending serving data to the labeling service for the next year, introduces additional assumptions and risks. This option requires analyzing the historical data and model performance, and finding the patterns that can explain the variations in the model performance over time. However, this can be difficult and unreliable, as the patterns may not be consistent or predictable, and may depend on various factors that are not captured by the data. Moreover, this option requires creating a schedule based on the past patterns, which may not reflect the future changes in the data or the environment. This can lead to either sending too much or too little data to the labeling service, resulting in either wasted cost or degraded performance. Option C: Comparing the cost of the labeling service with the lost revenue due to model performance degradation over the past year, and adjusting the frequency of model retraining accordingly, introduces additional challenges and trade-offs. This option requires estimating the cost of the labeling service and the lost revenue due to model performance degradation, which can be difficult and inaccurate, as they may depend on various factors that are not easily quantifiable or measurable. Moreover, this option requires finding the optimal balance between the cost and the performance, which can be subjective and variable, as different stakeholders may have different preferences and expectations. Furthermore, this option may not account for the potential impact of the model performance degradation on other aspects of the business, such as customer satisfaction, retention, or loyalty.

Answer: C
Explanation: The best option for monitoring the model to determine when retraining is necessary is to schedule a weekly query in BigQuery to compute the success metric. This option has the following advantages: It allows the model performance to be evaluated regularly, based on the actual outcome of the recommendations. By computing the success metric, which is the percentage of articles that are opened within two days and read for at least one minute, you can measure how well the model is achieving its objective and compare it with the acceptable baseline. It leverages the scalability and efficiency of BigQuery, which is a serverless, fully managed, and highly scalable data warehouse that can run complex queries over petabytes of data in seconds. By using BigQuery, you can access and analyze all the information needed to compute the success metric, such as the newsletter publication date, the article opening date, and the user reading time, without worrying about the infrastructure or the cost. It simplifies the model monitoring and retraining workflow, as the weekly query can be scheduled and executed automatically using BigQuerys built-in scheduling feature. You can also set up alerts or notifications to inform you when the success metric falls below the acceptable baseline, and trigger the model retraining process accordingly. The other options are less optimal for the following reasons: Option A: Using Vertex AI Model Monitoring to detect skew of the input features with a sample rate of 100% and a monitoring frequency of two days introduces additional complexity and overhead. This option requires setting up and managing a Vertex AI Model Monitoring service, which is a managed service that provides various tools and features for machine learning, such as training, tuning, serving, and monitoring. However, using Vertex AI Model Monitoring to detect skew of the input features may not reflect the actual performance of the model, as skew is the discrepancy between the distributions of the features in the training dataset and the serving data, which may not affect the outcome of the recommendations. Moreover, using a sample rate of 100% and a monitoring frequency of two days may incur unnecessary cost and latency, as it requires analyzing all the input features every two days, which may not be needed for the model monitoring. Option B: Scheduling a cron job in Cloud Tasks to retrain the model every week before the newsletter is created introduces additional cost and risk. This option requires creating and running a cron job in Cloud Tasks, which is a fully managed service that allows you to schedule and execute tasks that are invoked by HTTP requests. However, using Cloud Tasks to retrain the model every week may not be optimal, as it may retrain the model more often than necessary, wasting compute resources and cost. Moreover, using Cloud Tasks to retrain the model before the newsletter is created may introduce risk, as it may deploy a new model version that has not been tested or validated, potentially affecting the quality of the recommendations. Option D: Scheduling a daily Dataflow job in Cloud Composer to compute the success metric introduces additional complexity and cost. This option requires creating and running a Dataflow job in Cloud Composer, which is a fully managed service that runs Apache Airflow pipelines for workflow orchestration. Dataflow is a fully managed service that runs Apache Beam pipelines for data processing and transformation. However, using Dataflow and Cloud Composer to compute the success metric may not be necessary, as it may add more steps and overhead to the model monitoring process. Moreover, using Dataflow and Cloud Composer to compute the success metric daily may not be optimal, as it may compute the success metric more often than needed, consuming more compute resources and cost. Reference: [BigQuery documentation] [Vertex AI Model Monitoring documentation] [Cloud Tasks documentation] [Cloud Composer documentation] [Dataflow documentation]

Answer: B

Explanation:

The best option for deploying a scikit-learn classification model to production is to deploy an online

Vertex AI prediction endpoint and set the max replica count to 100. This option allows you to

leverage the power and scalability of Google Cloud to serve requests 24 and handle millions of

requests per second. Vertex AI is a unified platform for building and deploying machine learning

solutions on Google Cloud. Vertex AI can deploy a trained scikit-learn model to an online prediction

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

endpoint consists of one or more replicas, which are copies of the model that run on virtual

machines. The max replica count is a parameter that determines the maximum number of replicas

that can be created for the endpoint. By setting the max replica count to 100, you can enable the

endpoint to scale up to 100 replicas when the traffic increases, and scale down to zero replicas when

the traffic decreases. This can help minimize the cost of deployment, as you only pay for the

resources that you use. Moreover, you can use the autoscaling algorithm option to optimize the

scaling behavior of the endpoint based on the latency and utilization metrics1.

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

Option A: Deploying an online Vertex AI prediction endpoint and setting the max replica count to 1

would not be able to serve requests 24 and handle millions of requests per second. Setting the

max replica count to 1 would limit the endpoint to only one replica, which can cause performance

issues and service disruptions when the traffic increases. Moreover, setting the max replica count to

1 would prevent the endpoint from scaling down to zero replicas when the traffic decreases, which

can increase the cost of deployment, as you pay for the resources that you do not use1.

Option C: Deploying an online Vertex AI prediction endpoint with one GPU per replica and setting the

max replica count to 1 would not be able to serve requests 24 and handle millions of requests per

second, and would increase the cost of deployment. Adding a GPU to each replica would increase the

computational power of the endpoint, but it would also increase the cost of deployment, as GPUs

are more expensive than CPUs. Moreover, setting the max replica count to 1 would limit the

endpoint to only one replica, which can cause performance issues and service disruptions when the

traffic increases, and prevent the endpoint from scaling down to zero replicas when the traffic

decreases1. Furthermore, scikit-learn models do not benefit from GPUs, as scikit-learn is not

optimized for GPU acceleration2.

Option D: Deploying an online Vertex AI prediction endpoint with one GPU per replica and setting the

max replica count to 100 would be able to serve requests 24 and handle millions of requests per

second, but it would increase the cost of deployment. Adding a GPU to each replica would increase

the computational power of the endpoint, but it would also increase the cost of deployment, as

GPUs are more expensive than CPUs. Setting the max replica count to 100 would enable the

endpoint to scale up to 100 replicas when the traffic increases, and scale down to zero replicas when

the traffic decreases, which can help minimize the cost of deployment. However, scikit-learn models

do not benefit from GPUs, as scikit-learn is not optimized for GPU acceleration2. Therefore, using

GPUs for scikit-learn models would be unnecessary and wasteful.

Reference:

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

Systems, Week 2: Serving ML Predictions

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

production, 3.1 Deploying ML models to production

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

Production ML Systems, Section 6.2: Serving ML Predictions

Online prediction

Scaling online prediction

scikit-learn FAQ

Answer: A

Explanation:

A TPU VM is a virtual machine that has direct access to a Cloud TPU device. TPU VMs provide a

simpler and more flexible way to use Cloud TPUs, as they eliminate the need for a separate host VM

and network setup. TPU VMs also support interactive debugging tools such as TensorFlow Debugger

(tfdbg) and Python Debugger (pdb), which can help researchers develop and troubleshoot complex

models. A v3-8 TPU VM has 8 TPU cores, which can provide high performance and scalability for

training large models. SSHing into the TPU VM allows the user to run and debug the TensorFlow code

directly on the TPU device, without any network overhead or data transfer issues. Reference:

1: TPU VMs Overview

2: TPU VMs Quickstart

3: Debugging TensorFlow Models on Cloud TPUs

Answer: A
Explanation: 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]

Answer: D

Explanation:

The best option for investigating the tradeoffs between different parameter combinations is to

create an experiment in Vertex AI Experiments, create a Vertex AI pipeline with a custom model

training job as part of the pipeline, configure the pipelines parameters to include those you are

investigating, and submit multiple runs to the same experiment using different values for the

parameters. This option allows you to leverage the power and flexibility of Google Cloud to compare

the pipeline performance of the different parameter combinations measured in F1 score, time to

train, and model complexity. Vertex AI Experiments is a service that can track and compare the

results of multiple machine learning runs. Vertex AI Experiments can record the metrics, parameters,

and artifacts of each run, and display them in a dashboard for easy visualization and analysis. Vertex

AI Experiments can also help users optimize the hyperparameters of their models by using different

search algorithms, such as grid search, random search, or Bayesian optimization1. 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. A custom model training job is a type of pipeline step that can train a

custom model by using a user-provided script or container. A custom model training job can accept

pipeline parameters as inputs, which can be used to control the training logic or data source. By

creating an experiment in Vertex AI Experiments, creating a Vertex AI pipeline with a custom model

training job as part of the pipeline, configuring the pipelines parameters to include those you are

investigating, and submitting multiple runs to the same experiment using different values for the

parameters, you can create a reproducible and trackable approach to investigate the tradeoffs

between different parameter combinations.

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

Option A: Using BigQuery ML to create a boosted tree regressor and use the hyperparameter tuning

capability, configuring the hyperparameter syntax to select different input datasets, max tree depths,

and optimizer learning rates, and choosing the grid search option would not be able to handle

different input datasets as a hyperparameter, and would not be as flexible and scalable as using

Vertex AI Experiments and Vertex AI Pipelines. BigQuery ML is a service that can create and train

machine learning models by using SQL queries on BigQuery. BigQuery ML can perform

hyperparameter tuning by using the ML.FORECAST or ML.PREDICT functions, and specifying the

hyperparameters option. BigQuery ML can also use different search algorithms, such as grid search,

random search, or Bayesian optimization, to find the optimal hyperparameters. However, BigQuery

ML can only tune the hyperparameters that are related to the model architecture or training process,

such as max tree depth or learning rate. BigQuery ML cannot tune the hyperparameters that are

related to the data source, such as input dataset. Moreover, BigQuery ML is not designed to work

with Vertex AI Experiments or Vertex AI Pipelines, which can provide more features and flexibility for

tracking and orchestrating machine learning workflows2.

Option B: Creating a Vertex AI pipeline with a custom model training job as part of the pipeline,

configuring the pipelines parameters to include those you are investigating, and using the Bayesian

optimization method with F1 score as the target to maximize in the custom training step would not

be able to track and compare the results of multiple runs, and would require more skills and steps

than using Vertex AI Experiments and Vertex AI Pipelines. 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. A custom model training job is a type of pipeline step that can train a custom model

by using a user-provided script or container. A custom model training job can accept pipeline

parameters as inputs, which can be used to control the training logic or data source. However, using

the Bayesian optimization method with F1 score as the target to maximize in the custom training step

would require writing code, implementing the optimization algorithm, and defining the objective

function. Moreover, this option would not be able to track and compare the results of multiple runs,

as Vertex AI Pipelines does not have a built-in feature for recording and displaying the metrics,

parameters, and artifacts of each run3.

Option C: Creating a Vertex AI Workbench notebook for each of the different input datasets, running

different local training jobs with different combinations of the max tree depth and optimizer learning

rate parameters, and appending the results to a BigQuery table would not be able to track and

compare the results of multiple runs on the same platform, and would require more skills and steps

than using Vertex AI Experiments and Vertex AI Pipelines. Vertex AI Workbench is a service that

provides an integrated development environment for data science and machine learning. Vertex AI

Workbench allows users to create and run Jupyter notebooks on Google Cloud, and access various

tools and libraries for data analysis and machine learning. However, creating a Vertex AI Workbench

notebook for each of the different input datasets, running different local training jobs with different

combinations of the max tree depth and optimizer learning rate parameters, and appending the

results to a BigQuery table would require creating multiple notebooks, writing code, setting up local

environments, connecting to BigQuery, loading and preprocessing the data, training and evaluating

the model, and writing the results to a BigQuery table. Moreover, this option would not be able to

track and compare the results of multiple runs on the same platform, as BigQuery is a separate

service from Vertex AI Workbench, and does not have a dashboard for visualizing and analyzing the

metrics, parameters, and artifacts of each run4.

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 1: Architecting low-code

ML solutions, 1.1 Developing ML models by using BigQuery ML

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

Engineering for ML, Section 3.2: BigQuery for ML

Vertex AI Experiments

Vertex AI Pipelines

BigQuery ML

Vertex AI Workbench

Answer: A
Explanation: The easiest way to integrate custom Python code into the Kubeflow Pipelines SDK is to use the func_to_container_op function, which converts a Python function into a pipeline component. This function automatically builds a Docker image that executes the Python function, and returns a factory function that can be used to create kfp.dsl.ContainerOp instances for the pipeline. This option has the following benefits: It allows the data science team to reuse their existing Python code without rewriting it or packaging it into containers manually. It simplifies the component specification and implementation, as the function signature defines the component interface and the function body defines the component logic. It supports various types of inputs and outputs, such as primitive types, files, directories, and dictionaries. The other options are less optimal for the following reasons: Option B: Using the predefined components available in the Kubeflow Pipelines SDK to access Dataproc, and run the custom code there, introduces additional complexity and cost. This option requires creating and managing Dataproc clusters, which are ephemeral and scalable clusters of Compute Engine instances that run Apache Spark and Apache Hadoop. Moreover, this option requires writing the custom code in PySpark or Hadoop MapReduce, which may not be compatible with the existing Python code. Option C: Packaging the custom Python code into Docker containers, and using the load_component_from_file function to import the containers into the pipeline, introduces additional steps and overhead. This option requires creating and maintaining Dockerfiles, building and pushing Docker images, and writing component specifications in YAML files. Moreover, this option requires managing the dependencies and versions of the Python code and the Docker images. Option D: Deploying the custom Python code to Cloud Functions, and using Kubeflow Pipelines to trigger the Cloud Function, introduces additional latency and limitations. This option requires creating and deploying Cloud Functions, which are serverless functions that execute in response to events. Moreover, this option requires invoking the Cloud Functions from the Kubeflow Pipelines using HTTP requests, which can incur network overhead and latency. Additionally, this option is subject to the quotas and limits of Cloud Functions, such as the maximum execution time and memory usage. Reference: Building Python function-based components | Kubeflow Building Python Function-based Components | Kubeflow

Answer: B

Explanation:

The best option for resolving the training-serving skew alert is to update the model monitoring job to

use the more recent training data that was used to retrain the model. This option can help align the

baseline distribution of the model monitoring job with the current distribution of the production

data, and eliminate the false positive alerts. Model Monitoring is a service that can track and

compare the results of multiple machine learning runs. Model Monitoring can monitor the models

prediction input data for feature skew and drift. Training-serving skew occurs when the feature data

distribution in production deviates from the feature data distribution used to train the model. If the

original training data is available, you can enable skew detection to monitor your models for trainingserving skew. 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 features values in the training data. If

the distance score for a feature exceeds an alerting threshold that you set, Model Monitoring sends

you an email alert. However, if you retrain the model with more recent training data, and deploy it

back to the Vertex AI endpoint, the baseline distribution of the model monitoring job may become

outdated and inconsistent with the current distribution of the production data. This can cause the

model monitoring job to generate false positive alerts, even if the model performance is not

deteriorated. To avoid this problem, you need to update the model monitoring job to use the more

recent training data that was used to retrain the model. This can help the model monitoring job to

recalculate the baseline distribution and the distance scores, and compare them with the current

distribution of the production data. This can also help the model monitoring job to detect any true

positive alerts, such as a sudden change in the production data that causes the model performance

to degrade1.

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

Option A: Updating the model monitoring job to use a lower sampling rate would not resolve the

training-serving skew alert, and could reduce the accuracy and reliability of the model monitoring

job. The 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 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 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. Moreover, using a lower

sampling rate would not address the root cause of the training-serving skew alert, which is the

mismatch between the baseline distribution and the current distribution of the production data2.

Option C: Temporarily disabling the alert, and enabling the alert again after a sufficient amount of

new production traffic has passed through the Vertex AI endpoint, would not resolve the trainingserving

skew alert, and could expose the model to potential risks and errors. Disabling the alert

would stop the model monitoring job from sending email notifications when the distance score for a

feature exceeds the alerting threshold, but it would not stop the model monitoring job from

calculating and comparing the distributions and distance scores. Therefore, disabling the alert would

not address the root cause of the training-serving skew alert, which is the mismatch between the

baseline distribution and the current distribution of the production data. Moreover, disabling the

alert would prevent the model monitoring job from detecting any true positive alerts, such as a

sudden change in the production data that causes the model performance to degrade. This can

expose the model to potential risks and errors, and affect the user satisfaction and trust1.

Option D: Temporarily disabling the alert until the model can be retrained again on newer training

data, and retraining the model again after a sufficient amount of new production traffic has passed

through the Vertex AI endpoint, would not resolve the training-serving skew alert, and could cause

unnecessary costs and efforts. Disabling the alert would stop the model monitoring job from sending

email notifications when the distance score for a feature exceeds the alerting threshold, but it would

not stop the model monitoring job from calculating and comparing the distributions and distance

scores. Therefore, disabling the alert would not address the root cause of the training-serving skew

alert, which is the mismatch between the baseline distribution and the current distribution of the

production data. Moreover, disabling the alert would prevent the model monitoring job from

detecting any true positive alerts, such as a sudden change in the production data that causes the

model performance to degrade. This can expose the model to potential risks and errors, and affect

the user satisfaction and trust. Retraining the model again on newer training data would create a

new model version, but it would not update the model monitoring job to use the newer training data

as the baseline distribution. Therefore, retraining the model again on newer training data would not

resolve the training-serving skew alert, and could cause unnecessary costs and efforts1.

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

Sampling rate

Answer: A
Explanation: The best option for performing hyperparameter tuning on Vertex AI to determine the appropriate embedding dimension and the optimal learning rate is to use UNIT_LINEAR_SCALE for the embedding dimension, UNIT_LOG_SCALE for the learning rate, and a large number of parallel trials. This option has the following advantages: It matches the appropriate scaling type for each hyperparameter, based on their range and distribution. The embedding dimension is an integer hyperparameter that varies linearly between 16 and 64, so using UNIT_LINEAR_SCALE makes sense. The learning rate is a double hyperparameter that varies exponentially between 10e-05 and 10e-02, so using UNIT_LOG_SCALE is more suitable. It maximizes the exploration of the hyperparameter space, by using a large number of parallel trials. Since training time is not a concern, using more trials can help find the best combination of hyperparameters that maximizes model accuracy. The default Bayesian optimization tuning algorithm can efficiently sample the hyperparameter space and converge to the optimal values. The other options are less optimal for the following reasons: Option B: Using UNIT_LINEAR_SCALE for the embedding dimension, UNIT_LOG_SCALE for the learning rate, and a small number of parallel trials, reduces the exploration of the hyperparameter space, by using a small number of parallel trials. Since training time is not a concern, using fewer trials can miss some potentially good combinations of hyperparameters that maximize model accuracy. The default Bayesian optimization tuning algorithm can benefit from more trials to sample the hyperparameter space and converge to the optimal values. Option C: Using UNIT_LOG_SCALE for the embedding dimension, UNIT_LINEAR_SCALE for the learning rate, and a large number of parallel trials, mismatches the appropriate scaling type for each hyperparameter, based on their range and distribution. The embedding dimension is an integer hyperparameter that varies linearly between 16 and 64, so using UNIT_LOG_SCALE is not suitable. The learning rate is a double hyperparameter that varies exponentially between 10e-05 and 10e-02, so using UNIT_LINEAR_SCALE makes less sense. Option D: Using UNIT_LOG_SCALE for the embedding dimension, UNIT_LINEAR_SCALE for the learning rate, and a small number of parallel trials, combines the drawbacks of option B and option C. It mismatches the appropriate scaling type for each hyperparameter, based on their range and distribution, and reduces the exploration of the hyperparameter space, by using a small number of parallel trials. Reference: [Vertex AI: Hyperparameter tuning overview] [Vertex AI: Configuring the hyperparameter tuning job]

Answer: D

Explanation:

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 models 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 features 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 predictionsamplingrate 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 monitoringfrequency

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

Answer: D
Explanation: The best option for developing and comparing multiple models on a large-scale BigQuery table using TensorFlow and Vertex AI is to use TensorFlow I/Os BigQuery Reader to directly read the data. This option has the following advantages: It minimizes any bottlenecks during the data ingestion stage, as the BigQuery Reader can stream data from BigQuery to TensorFlow in parallel and in batches, without loading the entire table into memory or disk. The BigQuery Reader can also perform data transformations and filtering using SQL queries, reducing the need for additional preprocessing steps in TensorFlow. It leverages the scalability and performance of BigQuery, as the BigQuery Reader can handle hundreds of millions of records worth of training data efficiently and reliably. BigQuery is a serverless, fully managed, and highly scalable data warehouse that can run complex queries over petabytes of data in seconds. It simplifies the integration with Vertex AI, as the BigQuery Reader can be used with both custom and pre-built TensorFlow models on Vertex AI. Vertex AI is a unified platform for machine learning that provides various tools and features for data ingestion, data labeling, data preprocessing, model training, model tuning, model deployment, model monitoring, and model explainability. The other options are less optimal for the following reasons: Option A: Using the BigQuery client library to load data into a dataframe, and using tf.data.Dataset.from_tensor_slices() to read it, introduces memory and performance issues. This option requires loading the entire BigQuery table into a Pandas dataframe, which can consume a lot of memory and cause out-of-memory errors. Moreover, using tf.data.Dataset.from_tensor_slices() to read the dataframe can be slow and inefficient, as it creates one slice per row of the dataframe, resulting in a large number of small tensors. Option B: Exporting data to CSV files in Cloud Storage, and using tf.data.TextLineDataset() to read them, introduces additional steps and complexity. This option requires exporting the BigQuery table to one or more CSV files in Cloud Storage, which can take a long time and consume a lot of storage space. Moreover, using tf.data.TextLineDataset() to read the CSV files can be slow and error-prone, as it requires parsing and decoding each line of text, handling missing values and invalid data, and applying data transformations and validations. Option C: Converting the data into TFRecords, and using tf.data.TFRecordDataset() to read them, introduces additional steps and complexity. This option requires converting the BigQuery table into one or more TFRecord files, which are binary files that store serialized TensorFlow examples. This can take a long time and consume a lot of storage space. Moreover, using tf.data.TFRecordDataset() to read the TFRecord files requires defining and parsing the schema of the TensorFlow examples, which can be tedious and error-prone. Reference: [TensorFlow I/O documentation] [BigQuery documentation] [Vertex AI documentation]

Answer: B

Explanation:

The best option for deploying a scikit-learn model on Vertex AI with minimal additional code is to

wrap the model in a custom prediction routine (CPR) and build a container image from the CPR local

model. Upload your scikit-learn model container to Vertex AI Model Registry. Deploy your model to

Vertex AI Endpoints, and create a Vertex AI batch prediction job. This option allows you to leverage

the power and simplicity of Google Cloud to deploy and serve a scikit-learn model that supports both

online and batch prediction. Vertex AI is a unified platform for building and deploying machine

learning solutions on Google Cloud. Vertex AI can deploy a trained scikit-learn model to an online

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

also create a batch prediction job, which can provide high-throughput predictions for a large batch of

instances. A custom prediction routine (CPR) is a Python script that defines the logic for

preprocessing the input data, running the prediction, and postprocessing the output data. A CPR can

help you customize the prediction behavior of your model, and handle complex or non-standard data

formats. A CPR can also help you minimize the additional code, as you only need to write a few

functions to implement the prediction logic. A container image is a package that contains the model,

the CPR, and the dependencies. A container image can help you standardize and simplify the

deployment process, as you only need to upload the container image to Vertex AI Model Registry,

and deploy it to Vertex AI Endpoints. By wrapping the model in a CPR and building a container image

from the CPR local model, uploading the scikit-learn model container to Vertex AI Model Registry,

deploying the model to Vertex AI Endpoints, and creating a Vertex AI batch prediction job, you can

deploy a scikit-learn model on Vertex AI with minimal additional code1.

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

Option A: Uploading your model to the Vertex AI Model Registry by using a prebuilt scikit-learn

prediction container, deploying your model to Vertex AI Endpoints, and creating a Vertex AI batch

prediction job that uses the instanceConfig.instanceType setting to transform your input data would

not allow you to preprocess the input data for model inference, and could cause errors or poor

performance. A prebuilt scikit-learn prediction container is a container image that is provided by

Google Cloud, and contains the scikit-learn framework and the dependencies. A prebuilt scikit-learn

prediction container can help you deploy a scikit-learn model without writing any code, but it also

limits your customization options. A prebuilt scikit-learn prediction container can only handle

standard data formats, such as JSON or CSV, and cannot perform any preprocessing or postprocessing

on the input or output data. If your input data requires any transformation or normalization before

running the prediction, you cannot use a prebuilt scikit-learn prediction container. The

instanceConfig.instanceType setting is a parameter that determines the machine type and the

accelerator type for the batch prediction job. The instanceConfig.instanceType setting can help you

optimize the performance and the cost of the batch prediction job, but it cannot help you transform

your input data2.

Option C: Creating a custom container for your scikit-learn model, defining a custom serving function

for your model, uploading your model and custom container to Vertex AI Model Registry, and

deploying your model to Vertex AI Endpoints, and creating a Vertex AI batch prediction job would

require more skills and steps than using a CPR and a container image. A custom container is a

container image that contains the model, the dependencies, and a web server. A custom container

can help you customize the prediction behavior of your model, and handle complex or non-standard

data formats. A custom serving function is a Python function that defines the logic for running the

prediction on the model. A custom serving function can help you implement the prediction logic of

your model, and handle complex or non-standard data formats. However, creating a custom

container and defining a custom serving function would require more skills and steps than using a

CPR and a container image. You would need to write code, build and test the container image,

configure the web server, and implement the prediction logic. Moreover, creating a custom container

and defining a custom serving function would not allow you to preprocess the input data for model

inference, as the custom serving function only runs the prediction on the model3.

Option D: Creating a custom container for your scikit-learn model, uploading your model and custom

container to Vertex AI Model Registry, deploying your model to Vertex AI Endpoints, and creating a

Vertex AI batch prediction job that uses the instanceConfig.instanceType setting to transform your

input data would not allow you to preprocess the input data for model inference, and could cause

errors or poor performance. A custom container is a container image that contains the model, the

dependencies, and a web server. A custom container can help you customize the prediction behavior

of your model, and handle complex or non-standard data formats. However, creating a custom

container would require more skills and steps than using a CPR and a container image. You would

need to write code, build and test the container image, and configure the web server. The

instanceConfig.instanceType setting is a parameter that determines the machine type and the

accelerator type for the batch prediction job. The instanceConfig.instanceType setting can help you

optimize the performance and the cost of the batch prediction job, but it cannot help you transform

your input data23.

Reference:

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

Systems, Week 2: Serving ML Predictions

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

production, 3.1 Deploying ML models to production

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

Production ML Systems, Section 6.2: Serving ML Predictions

Custom prediction routines

Using pre-built containers for prediction

Using custom containers for prediction

Answer: C

Explanation:

The best option for configuring the workflow is to add the transformations as a preprocessing layer

in the TensorFlow models. This option allows you to leverage the power and simplicity of TensorFlow

to preprocess and transform the data with simple Python code. TensorFlow is a framework for

building and training machine learning models. TensorFlow provides various tools and libraries for

data analysis and machine learning. A preprocessing layer is a type of layer in TensorFlow that can

perform data preprocessing and feature engineering operations on the input data. A preprocessing

layer can help you customize the data transformation and preprocessing logic, and handle complex

or non-standard data formats. A preprocessing layer can also help you minimize the preprocessing

time, cost, and development effort, as you only need to write a few lines of code to implement the

preprocessing layer, and you do not need to create any intermediate data sources or pipelines. By

adding the transformations as a preprocessing layer in the TensorFlow models, you can use Vertex

AIs custom training service to train multiple TensorFlow models that read the data from BigQuery

and predict future sales1.

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

Option A: Writing the transformations into Spark that uses the spark-bigquery-connector and using

Dataproc to preprocess the data would require more skills and steps than using a preprocessing layer

in TensorFlow. Spark is a framework for distributed data processing and machine learning. Spark can

read and write data from BigQuery by using the spark-bigquery-connector, which is a library that

allows Spark to communicate with BigQuery. Dataproc is a service that can create and manage Spark

clusters on Google Cloud. Dataproc can help you run Spark jobs on Google Cloud, and scale the

clusters according to the workload. However, writing the transformations into Spark that uses the

spark-bigquery-connector and using Dataproc to preprocess the data would require more skills and

steps than using a preprocessing layer in TensorFlow. You would need to write code, create and

configure the Spark cluster, install and import the spark-bigquery-connector, load and preprocess the

data, and write the data back to BigQuery. Moreover, this option would create an intermediate data

source in BigQuery, which can increase the storage and computation costs2.

Option B: Writing SQL queries to transform the data in-place in BigQuery would not allow you to use

Vertex AIs custom training service to train multiple TensorFlow models that read the data from

BigQuery and predict future sales. BigQuery is a service that can perform data analysis and machine

learning by using SQL queries. BigQuery can perform data transformation and preprocessing by using

SQL functions and clauses, such as MIN, MAX, CASE, and TRANSFORM. BigQuery can also perform

machine learning by using BigQuery ML, which is a feature that can create and train machine

learning models by using SQL queries. However, writing SQL queries to transform the data in-place in

BigQuery would not allow you to use Vertex AIs custom training service to train multiple TensorFlow

models that read the data from BigQuery and predict future sales. Vertex AIs custom training service

is a service that can run your custom machine learning code on Vertex AI. Vertex AIs custom training

service can support various machine learning frameworks, such as TensorFlow, PyTorch, and scikitlearn.

Vertex AIs custom training service cannot support SQL queries, as SQL is not a machine

learning framework. Therefore, if you want to use Vertex AIs custom training service, you cannot use

SQL queries to transform the data in-place in BigQuery3.

Option D: Creating a Dataflow pipeline that uses the BigQueryIO connector to ingest the data,

process it, and write it back to BigQuery would require more skills and steps than using a

preprocessing layer in TensorFlow. Dataflow is a service that can create and run data processing and

machine learning pipelines on Google Cloud. Dataflow can read and write data from BigQuery by

using the BigQueryIO connector, which is a library that allows Dataflow to communicate with

BigQuery. Dataflow can perform data transformation and preprocessing by using Apache Beam,

which is a framework for distributed data processing and machine learning. However, creating a

Dataflow pipeline that uses the BigQueryIO connector to ingest the data, process it, and write it back

to BigQuery would require more skills and steps than using a preprocessing layer in TensorFlow. You

would need to write code, create and configure the Dataflow pipeline, install and import the

BigQueryIO connector, load and preprocess the data, and write the data back to BigQuery. Moreover,

this option would create an intermediate data source in BigQuery, which can increase the storage

and computation costs4.

Reference:

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

Systems, Week 2: Serving ML Predictions

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

models, 2.1 Developing ML models by using TensorFlow

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

Developing ML Models, Section 4.1: Developing ML Models by Using TensorFlow

TensorFlow Preprocessing Layers

Spark and BigQuery

Dataproc

BigQuery ML

Dataflow and BigQuery

Apache Beam

Answer: B
Explanation: Dynamic range quantization is a model optimization technique for reducing latency that reduces the numerical precision of the weights and activations of models. This technique can reduce the model size, memory usage, and inference time by up to 4x with negligible accuracy loss. Dynamic range quantization can be applied to a trained TensorFlow model without retraining, and it is suitable for mobile applications that require low latency and power consumption. Weight pruning, model distillation, and dimensionality reduction are also model optimization techniques for reducing latency, but they have some limitations or drawbacks compared to dynamic range quantization: Weight pruning works by removing parameters within a model that have only a minor impact on its predictions. Pruned models are the same size on disk, and have the same runtime latency, but can be compressed more effectively. This makes pruning a useful technique for reducing model download size, but not for reducing inference time. Model distillation works by training a smaller and simpler model (student) to mimic the behavior of a larger and complex model (teacher). Distilled models can have lower latency and memory usage than the original models, but they require retraining and may not preserve the accuracy of the teacher model. Dimensionality reduction works by reducing the number of features or dimensions in the input data or the model layers. Dimensionality reduction can improve the computational efficiency and generalization ability of models, but it may also lose some information or introduce noise in the data or the model. Dimensionality reduction also requires retraining or modifying the model architecture. Reference: [TensorFlow Model Optimization] [TensorFlow Model Optimization Toolkit ” Post-Training Integer Quantization] [Model optimization methods to cut latency, adapt to new data]

Answer: B
Explanation: The best option for creating a Dataflow pipeline for real-time anomaly detection is to load the model directly into the Dataflow job as a dependency, and use it for prediction. This option has the following advantages: It minimizes the serving latency, as the model prediction logic is executed within the same Dataflow pipeline that ingests and processes the data. There is no need to invoke external services or containers, which can introduce network overhead and latency. It simplifies the deployment and management of the model, as the model is packaged with the Dataflow job and does not require a separate service or container. The model can be updated by redeploying the Dataflow job with a new model version. It leverages the scalability and reliability of Dataflow, as the model prediction logic can scale up or down with the data volume and handle failures and retries automatically. The other options are less optimal for the following reasons: Option A: Containerizing the model prediction logic in Cloud Run, which is invoked by Dataflow, introduces additional latency and complexity. Cloud Run is a serverless platform that runs stateless containers, which means that the model prediction logic needs to be initialized and loaded every time a request is made. This can increase the cold start latency and reduce the throughput. Moreover, Cloud Run has a limit on the number of concurrent requests per container, which can affect the scalability of the model prediction logic. Additionally, this option requires managing two separate services: the Dataflow pipeline and the Cloud Run container. Option C: Deploying the model to a Vertex AI endpoint, and invoking this endpoint in the Dataflow job, also introduces additional latency and complexity. Vertex AI is a managed service that provides various tools and features for machine learning, such as training, tuning, serving, and monitoring. However, invoking a Vertex AI endpoint from a Dataflow job requires making an HTTP request, which can incur network overhead and latency. Moreover, this option requires managing two separate services: the Dataflow pipeline and the Vertex AI endpoint. Option D: Deploying the model in a TFServing container on Google Kubernetes Engine, and invoking it in the Dataflow job, also introduces additional latency and complexity. TFServing is a highperformance serving system for TensorFlow models, which can handle multiple versions and variants of a model. However, invoking a TFServing container from a Dataflow job requires making a gRPC or REST request, which can incur network overhead and latency. Moreover, this option requires managing two separate services: the Dataflow pipeline and the Google Kubernetes Engine cluster. Reference: [Dataflow documentation] [TensorFlow documentation] [Cloud Run documentation] [Vertex AI documentation] [TFServing documentation]

Answer: D

Explanation:

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 models 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

Answer: B
Explanation: The best option for productionizing a Keras model is to use TensorFlow Extended (TFX), a framework for building end-to-end machine learning pipelines that can handle large-scale data and complex workflows. TFX provides standard components for data ingestion, transformation, validation, analysis, training, tuning, serving, and monitoring. TFX pipelines can be orchestrated with Vertex AI Pipelines, a managed service that runs on Google Cloud Platform and leverages Kubernetes and Argo. Vertex AI Pipelines allows you to automate the execution of your TFX pipeline steps, schedule retraining jobs, and scale up or down the resources as needed. By using TFX and Vertex AI Pipelines, you can take advantage of the following benefits: You can reuse the existing code in your Jupyter notebook, as TFX supports Keras as a first-class citizen. You can also use the Keras Tuner to optimize your model hyperparameters. You can ensure data quality and consistency by using the TFX Data Validation component, which can detect anomalies, drift, and skew in your data. You can also use the TFX SchemaGen component to generate a schema for your data and enforce it throughout the pipeline. You can analyze your model performance and fairness by using the TFX Model Analysis component, which can produce various metrics and visualizations. You can also use the TFX Model Validation component to compare your new model with a baseline model and set thresholds for deploying the model to production. You can deploy your model to various serving platforms by using the TFX Pusher component, which can push your model to Vertex AI, Cloud AI Platform, TensorFlow Serving, or TensorFlow Lite. You can also use the TFX Model Registry to manage the versions and metadata of your models. You can monitor your model performance and health by using the TFX Model Monitor component, which can detect data drift, concept drift, and prediction skew in your model. You can also use the TFX Evaluator component to compute metrics and validate your model against a baseline or a slice of data. You can reduce the cost and complexity of managing your own infrastructure by using Vertex AI Pipelines, which provides a serverless environment for running your TFX pipeline. You can also use the Vertex AI Experiments and Vertex AI TensorBoard to track and visualize your pipeline runs. Reference: [TensorFlow Extended (TFX)] [Vertex AI Pipelines] [TFX User Guide]

Answer: C

Explanation:

The best option for adding explanations to your model code with minimal effort and providing

explanations that are as accurate as possible is to upload the custom model to Vertex AI Model

Registry and configure feature-based attribution by using sampled Shapley with input baselines. This

option allows you to leverage the power and simplicity of Vertex Explainable AI to generate feature

attributions for each prediction, and understand how each feature contributes to the model output.

Vertex Explainable AI is a service that can help you understand and interpret predictions made by

your machine learning models, natively integrated with a number of Googles products and services.

Vertex Explainable AI can provide feature-based and example-based explanations to provide better

understanding of model decision making. Feature-based explanations are explanations that show

how much each feature in the input influenced the prediction. Feature-based explanations can help

you debug and improve model performance, build confidence in the predictions, and understand

when and why things go wrong. Vertex Explainable AI supports various feature attribution methods,

such as sampled Shapley, integrated gradients, and XRAI. Sampled Shapley is a feature attribution

method that is based on the Shapley value, which is a concept from game theory that measures how

much each player in a cooperative game contributes to the total payoff. Sampled Shapley

approximates the Shapley value for each feature by sampling different subsets of features, and

computing the marginal contribution of each feature to the prediction. Sampled Shapley can provide

accurate and consistent feature attributions, but it can also be computationally expensive. To reduce

the computation cost, you can use input baselines, which are reference inputs that are used to

compare with the actual inputs. Input baselines can help you define the starting point or the default

state of the features, and calculate the feature attributions relative to the input baselines. By

uploading the custom model to Vertex AI Model Registry and configuring feature-based attribution

by using sampled Shapley with input baselines, you can add explanations to your model code with

minimal effort and provide explanations that are as accurate as possible1.

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

Option A: Creating an AutoML tabular model by using the BigQuery data with integrated Vertex

Explainable AI would require more skills and steps than uploading the custom model to Vertex AI

Model Registry and configuring feature-based attribution by using sampled Shapley with input

baselines. AutoML tabular is a service that can automatically build and train machine learning

models for structured or tabular data. AutoML tabular can use BigQuery as the data source, and

provide feature-based explanations by using integrated gradients as the feature attribution method.

However, creating an AutoML tabular model by using the BigQuery data with integrated Vertex

Explainable AI would require more skills and steps than uploading the custom model to Vertex AI

Model Registry and configuring feature-based attribution by using sampled Shapley with input

baselines. You would need to create a new AutoML tabular model, import the BigQuery data,

configure the model settings, train and evaluate the model, and deploy the model. Moreover, this

option would not use your existing custom model, which is already performing well, but create a new

model, which may not have the same performance or behavior as your custom model2.

Option B: Creating a BigQuery ML deep neural network model, and using the ML.EXPLAIN_PREDICT

method with the num_integral_steps parameter would not allow you to deploy the model to

production, and could provide less accurate explanations than using sampled Shapley with input

baselines. BigQuery ML is a service that can create and train machine learning models by using SQL

queries on BigQuery. BigQuery ML can create a deep neural network model, which is a type of

machine learning model that consists of multiple layers of neurons, and can learn complex patterns

and relationships from the data. BigQuery ML can also provide feature-based explanations by using

the ML.EXPLAIN_PREDICT method, which is a SQL function that returns the feature attributions for

each prediction. The ML.EXPLAIN_PREDICT method uses integrated gradients as the feature

attribution method, which is a method that calculates the average gradient of the prediction output

with respect to the feature values along the path from the input baseline to the input. The

num_integral_steps parameter is a parameter that determines the number of steps along the path

from the input baseline to the input. However, creating a BigQuery ML deep neural network model,

and using the ML.EXPLAIN_PREDICT method with the num_integral_steps parameter would not

allow you to deploy the model to production, and could provide less accurate explanations than

using sampled Shapley with input baselines. BigQuery ML does not support deploying the model to

Vertex AI Endpoints, which is a service that can provide low-latency predictions for individual

instances. BigQuery ML only supports batch prediction, which is a service that can provide highthroughput

predictions for a large batch of instances. Moreover, integrated gradients can provide less

accurate and consistent explanations than sampled Shapley, as integrated gradients can be sensitive

to the choice of the input baseline and the num_integral_steps parameter3.

Option D: Updating the custom serving container to include sampled Shapley-based explanations in

the prediction outputs would require more skills and steps than uploading the custom model to

Vertex AI Model Registry and configuring feature-based attribution by using sampled Shapley with

input baselines. A custom serving container is a container image that contains the model, the

dependencies, and a web server. A custom serving container can help you customize the prediction

behavior of your model, and handle complex or non-standard data formats. However, updating the

custom serving container to include sampled Shapley-based explanations in the prediction outputs

would require more skills and steps than uploading the custom model to Vertex AI Model Registry

and configuring feature-based attribution by using sampled Shapley with input baselines. You would

need to write code, implement the sampled Shapley algorithm, build and test the container image,

and upload and deploy the container image. Moreover, this option would not leverage the power

and simplicity of Vertex Explainable AI, which can provide feature-based explanations natively

integrated with Vertex AI services4.

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

Vertex Explainable AI

AutoML Tables

BigQuery ML

Using custom containers for prediction

Answer: C

Explanation:

The best option for implementing the processing steps so that they run at serving time, minimizing

code changes and infrastructure maintenance, and deploying the model into production as quickly as

possible, is to use the Predictor interface to implement a custom prediction routine. Build the custom

container, upload the container to Vertex AI Model Registry, and deploy it to a Vertex AI endpoint.

This option allows you to leverage the power and simplicity of Vertex AI to serve your XGBoost model

with minimal effort and customization. Vertex AI is a unified platform for building and deploying

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

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

custom prediction routine (CPR) is a Python script that defines the logic for preprocessing the input

data, running the prediction, and postprocessing the output data. A CPR can help you customize the

prediction behavior of your model, and handle complex or non-standard data formats. A CPR can also

help you minimize the code changes, as you only need to write a few functions to implement the

prediction logic. A Predictor interface is a class that inherits from the base class aiplatform.Predictor,

and implements the abstract methods predict() and preprocess(). A Predictor interface can help you

create a CPR by defining the preprocessing and prediction logic for your model. A container image is

a package that contains the model, the CPR, and the dependencies. A container image can help you

standardize and simplify the deployment process, as you only need to upload the container image to

Vertex AI Model Registry, and deploy it to Vertex AI Endpoints. By using the Predictor interface to

implement a CPR, building the custom container, uploading the container to Vertex AI Model

Registry, and deploying it to a Vertex AI endpoint, you can implement the processing steps so that

they run at serving time, minimize code changes and infrastructure maintenance, and deploy the

model into production as quickly as possible1.

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

Option A: Using FastAPI to implement an HTTP server, creating a Docker image that runs your HTTP

server, and deploying it on your organizations GKE cluster would require more skills and steps than

using the Predictor interface to implement a CPR, building the custom container, uploading the

container to Vertex AI Model Registry, and deploying it to a Vertex AI endpoint. FastAPI is a

framework for building web applications and APIs in Python. FastAPI can help you implement an

HTTP server that can handle prediction requests and responses, and perform data preprocessing and

postprocessing. A Docker image is a package that contains the model, the HTTP server, and the

dependencies. A Docker image can help you standardize and simplify the deployment process, as you

only need to build and run the Docker image. GKE is a service that can create and manage

Kubernetes clusters on Google Cloud. GKE can help you deploy and scale your Docker image on

Google Cloud, and provide high availability and performance. However, using FastAPI to implement

an HTTP server, creating a Docker image that runs your HTTP server, and deploying it on your

organizations GKE cluster would require more skills and steps than using the Predictor interface to

implement a CPR, building the custom container, uploading the container to Vertex AI Model

Registry, and deploying it to a Vertex AI endpoint. You would need to write code, create and

configure the HTTP server, build and test the Docker image, create and manage the GKE cluster, and

deploy and monitor the Docker image. Moreover, this option would not leverage the power and

simplicity of Vertex AI, which can provide online prediction natively integrated with Google Cloud

services2.

Option B: Using FastAPI to implement an HTTP server, creating a Docker image that runs your HTTP

server, uploading the image to Vertex AI Model Registry, and deploying it to a Vertex AI endpoint

would require more skills and steps than using the Predictor interface to implement a CPR, building

the custom container, uploading the container to Vertex AI Model Registry, and deploying it to a

Vertex AI endpoint. FastAPI is a framework for building web applications and APIs in Python. FastAPI

can help you implement an HTTP server that can handle prediction requests and responses, and

perform data preprocessing and postprocessing. A Docker image is a package that contains the

model, the HTTP server, and the dependencies. A Docker image can help you standardize and

simplify the deployment process, as you only need to build and run the Docker image. Vertex AI

Model Registry is a service that can store and manage your machine learning models on Google

Cloud. Vertex AI Model Registry can help you upload and organize your Docker image, and track the

model versions and metadata. Vertex AI Endpoints is a service that can provide online prediction for

your machine learning models on Google Cloud. Vertex AI Endpoints can help you deploy your

Docker image to an online prediction endpoint, which can provide low-latency predictions for

individual instances. However, using FastAPI to implement an HTTP server, creating a Docker image

that runs your HTTP server, uploading the image to Vertex AI Model Registry, and deploying it to a

Vertex AI endpoint would require more skills and steps than using the Predictor interface to

implement a CPR, building the custom container, uploading the container to Vertex AI Model

Registry, and deploying it to a Vertex AI endpoint. You would need to write code, create and

configure the HTTP server, build and test the Docker image, upload the Docker image to Vertex AI

Model Registry, and deploy the Docker image to Vertex AI Endpoints. Moreover, this option would

not leverage the power and simplicity of Vertex AI, which can provide online prediction natively

integrated with Google Cloud services2.

Option D: Using the XGBoost prebuilt serving container when importing the trained model into

Vertex AI, deploying the model to a Vertex AI endpoint, working with the backend engineers to

implement the pre- and postprocessing steps in the Golang backend service would not allow you to

implement the processing steps so that they run at serving time, and could increase the code

changes and infrastructure maintenance. A XGBoost prebuilt serving container is a container image

that is provided by Google Cloud, and contains the XGBoost framework and the dependencies. A

XGBoost prebuilt serving container can help you deploy a XGBoost model without writing any code,

but it also limits your customization options. A XGBoost prebuilt serving container can only handle

standard data formats, such as JSON or CSV, and cannot perform any preprocessing or postprocessing

on the input or output data. If your input data requires any transformation or normalization before

running the prediction, you cannot use a XGBoost prebuilt serving container. A Golang backend

service is a service that is implemented in Golang, a programming language that can be used for web

development and system programming. A Golang backend service can help you handle the

prediction requests and responses from the frontend, and communicate with the Vertex AI endpoint.

However, using the XGBoost prebuilt serving container when importing the trained model into

Vertex AI, deploying the model to a Vertex AI endpoint, working with the backend engineers to

implement the pre- and postprocessing steps in the Golang backend service would not allow you to

implement the processing steps so that they run at serving time, and could increase the code

changes and infrastructure maintenance. You would need to write code, import the trained model

into Vertex AI, deploy the model to a Vertex AI endpoint, implement the pre- and postprocessing

steps in the Golang backend service, and test and monitor the Golang backend service. Moreover,

this option would not leverage the power and simplicity of Vertex AI, which can provide online

prediction natively integrated with Google Cloud services2.

Reference:

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

Systems, Week 2: Serving ML Predictions

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

production, 3.1 Deploying ML models to production

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

Production ML Systems, Section 6.2: Serving ML Predictions

Custom prediction routines

Using pre-built containers for prediction

Using custom containers for prediction

Answer: B
Explanation: The best option for developing a solution that predicts the presence and severity of the disease with high accuracy is to develop an image segmentation ML model to locate the boundaries of the rust spots. Image segmentation is a technique that partitions an image into multiple regions, each corresponding to a different object or semantic category. Image segmentation can be used to detect and localize the rust spots in the images of crops, and measure their shape and size. This information can then be used to determine the presence and severity of the disease, as the rust spots are correlated to the disease symptoms. Image segmentation can also handle the variability of the rust spots, as it does not rely on predefined templates or thresholds. Image segmentation can be implemented using deep learning models, such as U-Net, Mask R-CNN, or DeepLab, which can learn from large-scale datasets and achieve high accuracy and robustness. The other options are not as suitable for developing a solution that predicts the presence and severity of the disease with high accuracy, because: Creating an object detection model that can localize the rust spots would only provide the bounding boxes of the rust spots, not their exact boundaries. This would result in less precise measurements of the shape and size of the rust spots, and might affect the accuracy of the disease prediction. Object detection models are also more complex and computationally expensive than image segmentation models, as they have to perform both classification and localization tasks. Developing a template matching algorithm using traditional computer vision libraries would require manually designing and selecting the templates for the rust spots, which might not capture the diversity and variability of the rust spots. Template matching algorithms are also sensitive to noise, occlusion, rotation, and scale changes, and might fail to detect the rust spots in different scenarios. Template matching algorithms are also less accurate and robust than deep learning models, as they do not learn from data. Developing an image classification ML model to predict the presence of the disease would only provide a binary or categorical output, not the location or severity of the disease. Image classification models are also less informative and interpretable than image segmentation models, as they do not provide any spatial information or visual explanation for the prediction. Image classification models might also suffer from class imbalance or mislabeling issues, as the presence of the disease might not be consistent or clear across the images. Reference: Image Segmentation | Computer Vision | Google Developers Crop diseases and pests detection based on deep learning: a review | Plant Methods | Full Text Using Deep Learning for Image-Based Plant Disease Detection Computer Vision, IoT and Data Fusion for Crop Disease Detection Using ¦ On Using Artificial Intelligence and the Internet of Things for Crop ¦ Crop Disease Detection Using Machine Learning and Computer Vision

Cisco

Microsoft

Amazon

Google Professional-Machine-Learning-Engineer Dumps Questions Answers

Professional-Machine-Learning-Engineer Features

Students Passed

Average Marks

Questions from this dumps

Total Questions

Google Professional-Machine-Learning-Engineer Dumps

Google Professional-Machine-Learning-Engineer Practice Test Helps You Turn Dreams To Reality!

Bulk Exams Package

2 Exams Files

10% off

3 Exams Files

15% off

5 Exams Files

20% off

10 Exams Files

25% off

Dumps4download Leads You To A 100% Success in First Attempt!

Interactive & Effective Professional-Machine-Learning-Engineer Dumps PDF + Online Test Engine

How Dumps4download Creates Better Opportunities for You!

Get an Absolutely Free Demo Today!

24/7 Online Support – Anytime, Anywhere

Features to use Dumps4download Professional-Machine-Learning-Engineer Dumps:

Google Professional-Machine-Learning-Engineer Frequently Asked Questions

Google Professional-Machine-Learning-Engineer Sample Questions

Question # 1

Question # 2

Question # 3

Question # 4

Question # 5

Question # 6

Question # 7

Question # 8

Question # 9

Question # 10

Question # 11

Question # 12

Question # 13

Question # 14

Question # 15

Question # 16

Question # 17

Question # 18

Question # 19

Question # 20

Question # 21

Question # 22

Question # 23

Question # 24

Question # 25

Question # 26

Question # 27

Question # 28

Question # 29

Question # 30

Question # 31

Question # 32

Question # 33

Question # 34

Question # 35

Question # 36

Testimonials

About us

Our Contacts

Newsletter