An excellent example of a code smell is using the new keyword. This indicates a hardcoded dependency where the creator controls the new object and its lifetime. This is also known as the Control Freak anti-pattern, but I prefer to box it as a code smell instead of an anti-pattern since the new keyword is not intrinsically wrong.At this point, you may be wondering how it is possible not to use the new keyword in object-oriented programming, but rest assured, we will cover that and expand on the control freak code smell in Chapter 7, Deep Dive into Dependency Injection.
Code smell – Long Methods
The long methods code smell is when a method extends to more than 10 to 15 lines of code. That is a good indicator that you should think about that method differently. Having comments that separate multiple code blocks is a good indicator of a method that may be too long.Here are a few examples of what the case might be:
The method contains complex logic intertwined in multiple conditional statements.
The method contains a big switch block.
The method does too many things.
The method contains duplications of code.
To fix this, you could do the following:
Extract one or more private methods.
Extract some code to new classes.
Reuse the code from external classes.
If you have a lot of conditional statements or a huge switch block, you could leverage a design pattern such as the Chain of Responsibility, or CQRS, which you will learn about in Chapter 10, Behavioral Patterns, and Chapter 14, Mediator and CQRS Design Patterns.
Usually, each problem has one or more solutions; you need to spot the problem and then find, choose, and implement one of the solutions. Let’s be clear: a method containing 16 lines does not necessarily need refactoring; it could be OK. Remember that a code smell indicates that there might be a problem, not that there necessarily is one—apply common sense.
Give your feedback straight to the author himself and chat to other early readers on our Discord server (find the “architecting-aspnet-core-apps-3e” channel under EARLY ACCESS SUBSCRIPTION).
The goal of this book is not to create yet another design pattern book; instead, the chapters are organized according to scale and topic, allowing you to start small with a solid foundation and build slowly upon it, just like you would build a program.Instead of a guide covering a few ways of applying a design pattern, we will explore the thought processes behind the systems we are designing from a software engineer’s point of view.This is not a magic recipe book; from experience, there is no magical recipe when designing software; there are only your logic, knowledge, experience, and analytical skills. Let’s define “experience” as your past successes and failures. And don’t worry, you will fail during your career, but don’t get discouraged by it. The faster you fail, the faster you can recover and learn, leading to successful products. Many techniques covered in this book should help you achieve success. Everyone has failed and made mistakes; you aren’t the first and certainly won’t be the last. To paraphrase a well-known saying by Roosevelt: the people that never fail are the ones who never do anything.At a high level:
This book explores basic patterns, unit testing, architectural principles, and some ASP.NET Core mechanisms.
Then, we move up to the component scale, exploring patterns oriented toward small chunks of software and individual units.
After that, we move to application-scale patterns and techniques, exploring ways to structure an application.
Some subjects covered throughout the book could have a book of their own, so after this book, you should have plenty of ideas about where to continue your journey into software architecture.
Here are a few pointers about this book that are worth mentioning:
The chapters are organized to start with small-scale patterns and then progress to higher-level ones, making the learning curve easier.
Instead of giving you a recipe, the book focuses on the thinking behind things and shows the evolution of some techniques to help you understand why the shift happened.
Many use cases combine more than one design pattern to illustrate alternate usage so you can understand and use the patterns efficiently. This also shows that design patterns are not beasts to tame but tools to use, manipulate, and bend to your will.
As in real life, no textbook solution can solve all our problems; real problems are always more complicated than what’s explained in textbooks. In this book, I aim to show you how to mix and match patterns to think “architecture” instead of giving you step-by-step instructions to reproduce.
The rest of the introduction chapter introduces the concepts we explore throughout the book, including refreshers on a few notions. We also touch on .NET, its tooling, and some technical requirements.In this chapter, we cover the following topics:
Following are some of the limitations of Explainable AI in Vertex AI:
Each attribution merely displays how much the attribute influenced the forecast for that case. A single attribution may not represent model behavior. Aggregate attributions is preferred over a dataset to understand approximate model behavior.
Model and data determine attributions. They can only show the model’s data patterns, not any underlying linkages. The target’s association with a feature does not depend on its strong attribution. The attribution indicates if the model predicts using the characteristic.
Attributions alone cannot determine quality of the model; it is recommended to consider assessment of the training data and evaluation metrics of the model.
Integrated gradients method works well for the differentiable models (where derivative of all the operations can be calculated in TensorFlow graph). Shapley method is used for the Non-differentiable models (non-differentiable operations in the TensorFlow network, such as rounding operations and decoding).
In this book, we started by understanding the cloud platform, a few important components of the cloud, and the advantages of the cloud platforms. We started working development of the machine learning models through Vertex AI AutoML for tabular, text, and image data, we deployed the trained models onto the endpoints for the online predictions. Even before entering into the complexity of the custom model building, we worked to understand how to leverage pre-build models of the platform to obtain predictions. For the custom models, we utilized a workbench for the code development for the model training and utilized docker images to submit the training jobs, also worked on the hyperparameter tuning to further enhance the model performance using Vizier. We worked on the pipeline components of the platform to train the model and evaluate and deploy the model for online predictions using both Kubeflow and TFX. We worked on creating a centralized repository for the features using the feature store of the Vertex AI. This is the last chapter of the book, where we learned about the explainable AI, need of it. We trained the AutoML classification model for image and tabular data for the explanations and obtained the explanations using the Python code. GCP is adding lot of new components and features to enhance its capability, check the platform (documentation of the platform) regularly to keep yourself updated.
Once the model is deployed successfully, open the Jupyter lab from the workbench created and enter the Python code given in the following steps: Step 1: Install the required packages Type the following Python code to install the required packages: !pip install tensorflow !pip install pip install google-cloud-aiplatform==1.12.1
Step 2: Kernel restart Type following commands in the next cell, to restart the kernel: (Users can restart kernel from the GUI as well): import os import IPython if not os.getenv(“”): Ipython.Application.instance().kernel.do_shutdown(True)
Step 3: Importing required packages Once the kernel is restarted, run the following lines of codes to import the packages: import base64 import tensorflow as tf import google.cloud.aiplatform as gcai import explainable_ai_sdk import io import matplotlib.image as mpimg import matplotlib.pyplot as plt
Step 4: Input for prediction and explanation Choose any image from the training set (stored in the cloud storage for the prediction) and provide the full path of the image chosen in the following code. Run the cell to read the image and covert the image to the required format: img_input = tf.io.read_file(“gs://AutoML_image_data_exai/Kayak/adventure-clear-water-exercise-1836601.jpg”) b64str = base64.b64encode(img_input.numpy()).decode(“utf-8”) instances_image = [{“content”: b64str}]
Step 5: Selection of the endpoint select Run the following lines of code to select the endpoint where the model is deployed. In this method, we are using the display name of the endpoint (instead of the endpoint ID). Image_ex is the endpoint name where the model is deployed. Full path of the endpoint (along with the endpoint ID) will be displayed in the output: endpoint = gcai.Endpoint(gcai.Endpoint.list( filter=f’display_name={“image_ex”}’, order_by=’update_time’)[-1].gca_resource.name) print(endpoint)
Step 6: Image prediction Run the following lines of code to get the prediction from the deployed model: prediction = endpoint.predict(instances=instances_image) print(prediction) Prediction results will be displayed as shown in the following figure which contains display names and the probability of the classes:
Figure 10.15: Image classification prediction result Note: Since we are running this code using the Vertex AI workbench, we are not using service account for authentication. Step 7: Explanations Run the following lines of codes to get the explanations for the input image: response = endpoint.explain(instances=instances_image)
for explanation in response.explanations: attributions = dict(explanation.attributions[0].feature_attributions) image_ex = io.BytesIO(base64.b64decode(attributions[“image”][“b64_jpeg”])) plt.imshow(mpimg.imread(image_ex, format=”JPG”), interpolation=”nearest”) plt.show()
The output of the explanations is shown in the figure. Highlighted areas in green indicates areas/pixels which played important role for the prediction of the image:
Figure 10.16: Image classification model explanation
Once the model is trained, it needs to be deployed to end point for online predictions. Also create a workbench to get the predictions (python workbench will suffice). Follow the steps mentioned in the chapter Vertex AI workbench & custom model training., for creation of the workbench (Python workbench will suffice). Follow the below mentioned steps for the deployment of the models.
Step 1: Trained model listed under Model registry
Follow the below mentioned step to deploy the trained model:
Figure 10.10: Model registry
Click the trained model and then click on the version 1 of the model.
Step 2: Deploy to end point
Once the model is selected (along with the version) users will get the option to evaluate the model, deploy and test the model, and so on. Follow the steps mentioned below to deploy the model:
Figure 10.11: Image classification model deployment
Click DEPLOY AND TEST.
Click DEPLOY TO ENDPOINT.
Step 3: Define end point
Follow the steps mentioned below to define the end point:
Set the Number of compute nodes for predictions to be 1.
Enable the Explainability options.
Click EDIT.
Step 5: Feature attribution method selection
Follow the below mentioned steps to set the feature attribution method selection. In this example we are using Integrated gradients method for the explanations:
Select Integrated gradients method for feature attribution method (Keep the values same for the all the parameters, what was set during the training phase).
Click DONE.
Click DEPLOY.
Check if the model is deployed properly and then proceed with the python code to get predictions and explanations.
Each approach for attributing features is based on Shapley values, which is an algorithm derived from cooperative game theory that gives credit for a given result to each participant in a game. When this concept is applied to models for machine learning, it indicates that each model feature is dealt with as if it were a “player” in the game. The Vertex Explainable AI provides a certain amount of credit to each individual characteristic based on its weight in the overall forecast:
Sampled Shapley method: The sampled Shapley technique offers an estimate of the actual Shapley values via the use of sampling. Tabular models created using AutoML make use of the sampled Shapley approach to determine the relevance of features. For these models, which are meta-ensembles of tree and neural network structures, the Sampled Shapley method performs quite well.
Integrated gradients method: Along an integral route, the integrated gradients approach calculates the gradient of the prediction output with respect to the characteristics of the input. This is done to get an accurate result. Calculations of the gradients are performed at various time intervals along a scaling parameter. Utilizing the Gaussian quadrature rule allows for the calculation of the size of each interval. (When dealing with picture data, think of this scaling option as a “slider” that sets all the image’s pixels to a black value.) The integration of the gradients is done as follows:
An approximation of the integral may be found by using a weighted average.
Calculations are performed to get the element-wise product of the original input and the averaged gradients.
XRAI method: To discover which parts of a picture that contribute the most to a certain prediction of class, the XRAI approach uses a combination of the integrated gradients method and some extra phases.
Pixel-level attribution: XRAI can do pixel-level attribution for the picture that is sent into it. In this stage of the process, XRAI makes use of the integrated gradients approach, applying it to both, a black and a white baseline.
Over segmentation: XRAI generates a tiny patch over the picture by over segmentation , which is done independently of pixel-level attribution. In order to construct the picture segments, XRAI takes advantage of Felzenswalb’s graph-based technique.
Region selection: XRAI compiles the pixel-level attribution included inside each segment to calculate the attribution density of that segment. XRAI assigns a ranking to each segment based on these values, and then it arranges the segments from most positive to least positive. This identifies which parts of the picture contribute the most strongly to a certain class prediction, as well as which parts of the image are most prominent.
All types of models are supported for feature-based explanations. Classification models are supported for AutoML images and classification, and regression models are supported for AutoML tabular models.
In the case of explanations based on examples, Vertex AI makes use of the closest neighbor search to produce a list of instances (usually taken from the training set) that are most comparable to the input. These examples allow users to investigate and clarify the behavior of the model since users can reasonably anticipate that comparable inputs would result in similar predictions.
Consider the following scenario: users have a model that analyzes photos to determine whether they depict a bird or an aircraft; however, the model incorrectly identifies certain birds as planes. To figure out what is going on, we may extract other photos from the training set that is comparable to the one we are looking at and utilize example-based explanations to explain what is occurring. When we look at those instances, we see that many of the incorrectly identified birds and the training examples that are comparable to them are dark silhouettes and that most of the dark silhouettes that were aircraft were found in the training set. This suggests that users might potentially increase the quality of the model by including more silhouetted birds in the training set.
Explanations that are based on examples may also help identify confusing inputs that might be improved with human labelling. Models that provide embedding or latent representation for input variables are supported. Tree based models which do not provide embeddings for the inputs are not supported in examples-based explanations.
Feature-based explanations is another way of explaining model output based on the features. The amount of contribution that each feature in the model made to the predictions that were made for a particular instance is shown by the feature attributions. When users make a request for predictions, they will get anticipated values that are suitable for the model you are using. Feature attribution info will be provided when users request for the explanations.
Feature attributions work on image and tabular data. They are supported for AutoML and custom trained models. (Classification models only for image data and classification/regression models for tabular data).
Artificial intelligence has the ability to automate judgments, and the outcomes of such decisions may have both beneficial and bad effects on businesses. It is essential to have an understanding of how AI comes to its conclusions, just as it is essential to have this understanding when recruiting decision is made for the business. A great number of companies are interested in using AI, but are hesitant to hand over decision-making authority to the model or AI simply because they do not yet trust the model. Explainability is beneficial in this regard since it offers insights into the decision-making process that models use. Explainable AI is a crucial component in the process of applying ethics to the usage of AI in business. Explainable AI is predicated on the notion that AI-based applications and technology should not be opaque “black box” models that are incomprehensible to regular people. Figure 10.1 shows the difference between AI and Explainable AI:
Figure 10.1: Explainable AI
In the majority of the scenarios developing complex models is far easier than convincing stakeholders that the model is capable of producing decisions that are superior to those produced by humans. It is not the same thing as having greater accuracy scores or a lower RMSE to make a better judgment. A correct conclusion may be reached by providing accurate data as input. In many cases, the person making the choice is the one who needs to comprehend it. For them to feel at ease handing over the decision-making to the model, they need to understand how the model came to its conclusions.
Explainable AI is essential to the development of responsible AI because it offers an adequate amount of transparency and responsibility for the choices made by complicated AI systems. This is of utmost importance when it comes to artificial intelligence systems that have a substantial influence on the lives of people.
Explainable AI of Vertex AI provides explanations that are either feature-based or example-based in order to give a better understanding of how models make decisions. Anyone who builds or uses machine learning will gain new abilities if they learn how a model behaves and how it is influenced by its training dataset. These new abilities will allow users to improve their models, increase their confidence in their predictions, and understand when and why things work.
Step 12: Fetching feature values Feature values can be extracted from the feature store with the help of an online service client which has been created in Step 7 (Creation of feature store). Run the following lines of code to fetch data from the feature for a specific employee ID: resp_data = client_data.streaming_read_feature_values( featurestore_online_service.StreamingReadFeatureValuesRequest( entity_type=client_admin.entity_type_path( Project_id, location, featurestore_name, Entity_name ), entity_ids=[“65438”], feature_selector=FeatureSelector(id_matcher=IdMatcher(ids=[“employee_id”,”education”,”gender”,”no_of_trainings”,”age”])), ) ) print(resp_data)
The output will be stored in the resp_data variable and it is an iterator. Run the following lines of code to extract and parse the data from the iterator: names_col=[] for resp in resp_data: if resp.header.feature_descriptors != “”: for head in resp.header.feature_descriptors: names_col.append(head.id) try: values=[] for items in resp.entity_view.data: if items.value.string_value !=””:values.append(items.value.string_value) elif items.value.int64_value !=””:values.append(items.value.int64_value) except:pass print(“Feature Names”,names_col) print(“Feature Values”,values)
The output of the cell is shown in Figure 9.21:
Figure 9.21: Data extracted from the feature store Deleting resources We have utilized cloud storage to store the data and delete the CSV file from the cloud storage manually. Feature store is a cost-incurring resource on GCP, ensure to delete them. Also, the feature store cannot be deleted from the web console or GUI, we need to delete it through programming. Run the below-mentioned lines of code to delete the feature store (both the feature stores were created using GUI and Python). Check if the landing page of the feature store after running the code to ensure it is deleted (the landing page should look like the Figure 9.4): client_admin.delete_featurestore( request=fs_s.DeleteFeaturestoreRequest( name=client_admin.featurestore_path(Project_id, location, featurestore_name), force=True, ) ).result() featurestore_name=employee_fs_gui client_admin.delete_featurestore( request=fs_s.DeleteFeaturestoreRequest( name=client_admin.featurestore_path(Project_id, location, featurestore_name), force=True, ) ).result()
Below listed are few of the best practices for using Feature store of Vertex AI:
Model features to multiple entities: Some features might be used in multiple entities (like clicks per product at user level). In this kind of scenarios, it is best to create a separate entity to group shared features.
Access control for multiple teams: Multiple teams like data scientists, ML researchers, Devops, and so on, may require access to the same feature store but with different level of permissions. Resource level IAM policies can be used to restrict the access to feature store or particular entity type.
Ingesting historical data (backfilling): It is recommended to stop online serving while ingesting the historical data to prevent any changes to the online store.
Cost optimization:
Autoscaling: Instead of maintaining a high node count, autoscaling allows Vertex AI Feature Store to analyze traffic patterns and automatically modify the number of nodes up or down based on CPU consumption and also works better for cost optimization.
Recommended to provide a startTime in the batchReadFeatureValues or exportFeatureValues request to optimize offline storage costs during batch serving and batch export.
In this chapter, we learned about the feature store of Vertex AI, and worked on the creation of the feature store, entity type, adding features, and ingesting feature values using web console and Python.
In the next chapter, we will start understanding explainable AI, and how explainable AI works on Vertex AI.
In the previous section, we worked on a feature store for the creation and uploading of feature values using the GUI approach. In this section, we shall create another feature store, ingest values, and also fetch the values from the feature store.
We will be using the Python 3 notebook file to type commands for working on the feature store. Follow the following-mentioned steps to create a Python file and type the Python codes given in this section.
Step 1: Create a Python notebook file Once the workbench is created, open Jupyterlab and follow the steps mentioned in Figure 9.17 to create a Python notebook file:
Figure 9.17: New launcher window of notebook
Click the new launcher.
Double-click the Python 3 notebook file to create one.
Step 2: Package installation Run the following commands to install the google cloud AI platform package. (It will take a few minutes to install the packages): USER=”–user” !pip install {USER} google-cloud-aiplatform
Step 3: Kernel restart Type the following commands in the next cell, to restart the kernel. (users can restart the kernel from the GUI as well): import os import IPython if not os.getenv(“”): IPython.Application.instance().kernel.do_shutdown(True)
Step 4: Importing the installed packages Run the following-mentioned codes in a new cell to import the required packages: import google.cloud.aiplatform_v1 from google.cloud.aiplatform_v1.types import featurestore_service as fs_s from google.cloud.aiplatform_v1.types import featurestore as fs from google.cloud.aiplatform_v1.types import feature from google.cloud.aiplatform_v1.types import entity_type from google.cloud.aiplatform_v1.types import io from google.protobuf.timestamp_pb2 import Timestamp from google.cloud.aiplatform_v1.types.featurestore_service import ImportFeatureValuesRequest from google.cloud.aiplatform_v1.types import FeatureSelector, IdMatcher from google.cloud.aiplatform_v1.types import featurestore_online_service import datetime
Step 5: Setting up the project and other variables Run the following-mentioned line of codes in a new cell to set the project to the current one and also define variables to store the path for multiple purposes: Project_id=”vertex-ai-gcp-1” featurestore_name=”employee_fs_pysdk” Entity_name=”emp_entity_pysdk” location = “us-central1” endpoint = “us-central1-aiplatform.googleapis.com”
Step 6: Connecting to the feature store Connection to the feature store is the first step to work on the feature store. We create a connection to the feature store through the service client to create and ingest values to it using FeaturestoreServiceClient.
FeaturestoreOnlineServingServiceClient is used to fetch the feature values from the feature store. Run the below-mentioned line of codes to complete the connection: client_admin = google.cloud.aiplatform_v1.FeaturestoreServiceClient(client_options={“api_endpoint”: endpoint}) client_data = google.cloud.aiplatform_v1.FeaturestoreOnlineServingServiceClient(client_options={“api_endpoint”: endpoint}) fs_resource_path = client_admin.common_location_path(Project_id, location)
Step 7: Creation of feature store Instead of using the feature store that has been created from the GUI approach, we will create a new one. Feature store name, location, and project information are already in Step 5 (Setting up the project and other variables). Run the following code to create the feature store. The status of the feature store will be displayed in the results, as shown in Figure 9.18. The feature store creation procedure is a long-running operation, they are asynchronous jobs. except PI calls like updating or removing feature stores follow the same procedure. create_fs = client_admin.create_featurestore( fs_s.CreateFeaturestoreRequest( parent=fs_resource_path, featurestore_id=featurestore_name, featurestore=fs.Featurestore( online_serving_config=fs.Featurestore.OnlineServingConfig( fixed_node_count=1 print(create_fs.result()) client_admin.get_featurestore(name=client_admin.featurestore_path(Project_id, location, featurestore_name))
