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

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

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

model around a specific input1.

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

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

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

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

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

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

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

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

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

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

not for tabular data3.

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

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

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

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

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

Reference:

Local surrogate models

Shapley value

Vertex Explainable AI overview

Integrated gradients

Feature importance

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

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

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

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

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

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

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

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

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

such as Docker containers or Java archives2

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

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

file path3

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

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

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

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

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

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

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

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

repository5

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

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

trigger.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

has the following advantages:

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

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

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

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

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

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

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

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

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

services.

The other options are less optimal for the following reasons:

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

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

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

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

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

and do not support parallelism or optimization techniques.

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

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

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

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

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

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

tedious and time-consuming.

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

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

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

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

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

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

pipeline, which can be tedious and time-consuming.

Reference:

[tf.data: Build TensorFlow input pipelines]

[Image augmentation | TensorFlow Core]

[Dataflow documentation]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

the target utilization percentage and the autoscaling metric1.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

savings, and performance improvement2.

Reference:

Configure compute resources for prediction | Vertex AI | Google Cloud

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

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

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

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

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

would not account for the different feature selections.

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

the management effort and complexity of the pipeline.

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

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

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

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

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

properly for each model.

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

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

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

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

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

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

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

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

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

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

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

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

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

efficiency.

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

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

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

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

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

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

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

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

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

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

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

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

image classification model.

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

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

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

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

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

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

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

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

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

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

architecture.

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

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

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

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

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

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

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

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

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

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

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

handle the categorical features.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

data transfer and access costs1.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

execution time and cost1.

Reference:

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

Systems, Week 3: MLOps

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

production, 3.2 Automating ML workflows

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

Production ML Systems, Section 6.4: Automating ML Workflows

Vertex AI Pipelines

Caching

Pipeline parameters

Machine types

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

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

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

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

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

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

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

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

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

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

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

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

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

of the TPU capacity1.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Reference:

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

Architectures, Week 1: Introduction to ML Models and Architectures

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

solutions, 2.1 Designing ML models

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

Models and Architectures, Section 4.1: Designing ML Models

Use TPUs

Triose phosphate utilization and beyond: from photosynthesis to end …

Cloud TPU performance guide

Google TPU: Architecture and Performance Best Practices - Run

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

individual contribution of each feature for a given prediction.

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

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

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

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

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

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

Reference:

Local feature importance

Getting local feature importance values

Correlation with target values

Data summary page

Feature importance percentages

[Model evaluation page]

[Varying features independently]

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

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

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

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

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

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

following web search results:

Normalization | Machine Learning | Google for Developers

NORMALIZATION TECHNIQUES IN TRAINING DNNS: METHODOLOGY, ANALYSIS AND …

Visualizing Different Normalization Techniques | by Dibya … - Medium

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