Learning Salesforce Einstein: Add artificial intelligence capabilities to your business solutions with Heroku, PredictiveIO, and Force

As per Wikipedia:

Machine learning in general comprises three major steps:

The high level major steps of any machine learning system

In this chapter, we will cover a simple experiment using Google's Prediction API with Salesforce data, and, in the later chapters, we will introduce you to the PredictionIO part of Einstein offerings from Salesforce, which is an open source Machine Learning Server that allows developers and data scientists to capture data via its Event server, build predictive models with algorithms, and then deploy it as a web service.

A neural network is a set of algorithms designed to recognize patterns. Neural networks are superficially based on how the brain works.

They consist of a set of nodes (similar to human brain neurons) arranged in multiple layers, with weighted interconnections between them. Each neuron combines a set of input values to produce an output value, which in turn is passed on to other neurons downstream. Artificial neural networks are used in Deep Learning.

In Deep Learning, the neural network has multiple layers. At the top layer, the network trains on a specific set of features and then sends that information to the next layer. The network takes that information, combines it with other features and passes it to the next layer, and so on.

Deep Learning has increased in popularity because it has proven to outperform other methodologies for machine learning. Due to the advancement of distributed computing resources and businesses generating an influx of image, text, and voice data, Deep Learning can deliver insights that weren't previously possible.

Consider the following diagram:

Deep learning diagram. (Source and credit - http://www.nanalyze.com/2016/11/artificial-intelligence-definition/)

From an example from the U.S. government report, in an image recognition application, a first layer of units might combine the raw data of the image to recognize simple patterns in the image; a second layer of units might combine the results of the first layer to recognize patterns of patterns; a third layer might combine the results of the second layer, and so on. We train neural networks by feeding them lots of delicious big data to learn from.

Salesforce Einstein offers Predictive Vision Services (currently in Pilot) for training and solving image recognition use cases. We will discuss in detail how to use these services to bring the power of image recognition to the CRM apps.

Natural language processing (NLP) is the ability of computers to understand human language and speeches. A good example for this is Google Translator or a Google Voice Search. Modern day NLP systems use machine learning to detect patterns.

Cognitive computing involves self-learning systems that use data mining (big data), pattern recognition (machine learning), and natural language processing to mimic the way the human brain works. The difference between Artificial Intelligence and cognitive computing boils down to the idea that the former tells the user what course of action to take based on its analysis while the latter provides information to help the user decide. The goal of cognitive computing is to automatically solve IT problems without human intervention.

Humans have been finding patterns everywhere, ranging from astronomy to biology and physics. A pattern is a set of object/concept/phenomena where elements are like one another in certain aspects.

Statistical and structural patterns form the basis of machine learning.

Data mining is the process of finding patterns or correlations among dozens of fields in a relational database.

Data mining consists of the following five major elements:

Graphics processing units (GPU) basically help computers work much faster than those operating with a central processing unit (CPU) alone. Some companies have built their own versions of GPUs. For example, Google being Google, the technology giant has a chip it calls the Tensor processing unit (TPU), which supports the software engine (TensorFlow) that drives its Deep Learning services.

Universal Container (fictitious company) wants to find the probability of opportunity closure using their existing data. We will help them integrate Google Predictive API with Salesforce to predict the probability of the Salesforce opportunity closure based on the expected revenue and the opportunity type, which in turn can help them forecast revenue better.

Let's take an opportunity dataset from Salesforce, upload it into the Google storage, and build a regression type predictive model, train the model, and use it to predict the probability of the opportunity closure.

This section covers the steps required to experiment with Google Prediction API and Salesforce:

The project creation screen in the Google console

Note that the CSV data here is a report extract of opportunity data from Salesforce. You can extract data using the Salesforce standard reporting interface. You will need to create a custom probability field on the Salesforce opportunity object to track the probability from the prediction API.

Check the following screenshot of the Dataset sample. The data samples can be taken from your Salesforce organization, and, in case you want to use the one used in this book, you can get it from the git repository (https://github.com/PacktPublishing/Learning-Salesforce-Einstein/blob/master/Chapter1/SFOpportunity.csv):

The regression type predictive model uses a numeric answer for the question based on the previous samples. For this example, we will use this regression type predictive model. Take a look at the file located at (https://github.com/PacktPublishing/Learning-Salesforce-Einstein/blob/master/Chapter1/SFOpportunity.csv). The first column is probability, the second column is opportunity stage and the last column is the opportunity revenue. If you look carefully, you will notice that there is some correlation between the type of opportunity, expected revenue, and probability.

If you observe the dataset sample closely, you will see that for opportunities of type Existing customers, the higher the expected revenue, the more the probability.

To train the Dataset, we will leverage the Prediction API provided by Google. The complete set of APIs is listed in the following table:

If you recall, machine learning consists of three steps:

The following diagram shows the Integration Architecture that we have adopted for experimenting with Google Prediction API and Salesforce Data:

Integration Architecture For Using Google Prediction API with Salesforce

The data will be loaded into the Google Cloud bucket and trained using Prediction API manually using the console, and a model is formed. We will submit the query to the formed model by triggering an HTTP request to the Google Prediction API from Salesforce. The architecture is purposefully kept very simple to help readers grasp the fundamentals before we approach Prediction API in detail.

The following are the steps required to train the dataset via Google Prediction API. Note that we will use prediction.trainedmodels.insert to train the model:

The following screenshot shows how one can train the model:

The request and response JSON are shown as follows. Note that the learned-maker-155103 is the Project ID. Replace with your current Project ID.

Request Payload:

        POST https://www.googleapis.com/prediction/v1.6/projects
        /learned-maker-155103/trainedmodels
        {
          "modelType": "regression",
          "id": "opportunity-predictor",
          "storageDataLocation": 
          "salesforceeinstein/SFOpportunity.csv"
        }

Carefully, note that we have pointed the location in Cloud Storage where our data resides. Once successful, we get a response from the API, which is shown as follows:

Response Payload:

        200
        {
          "kind": "prediction#training",
          "id" : "opportunity-predictor",
          "selfLink": "https://www.googleapis.com/prediction/v1.6
          /projects/learned-maker-155103/trainedmodels/opportunity-
          predictor", "storageDataLocation":  
          "salesforceeinstein/SFOpportunity.csv"
        }

We can monitor the status of the data training via API prediction.trainedmodels.get.

The request to execute in the console is as follows:

Request Payload:

       GET https://www.googleapis.com/prediction/v1.6/
       projects/learned-maker-155103/trainedmodels/opportunity-
       predictor

Response Payload:

       200
       {
         "kind": "prediction#training",
         "id": " opportunity-predictor",
         "selfLink": "https://www.googleapis.com/prediction/v1.6/
         projects/learned-maker-155103/trainedmodels/opportunity-
         predict",
         "created": "2017-01-18T19:10:27.752Z",
         "trainingComplete": "2017-01-18T19:10:48.584Z",
         "modelInfo": {
           "numberInstances": "18",
           "modelType": "regression",
           "meanSquaredError": "79.61"
         },
          "trainingStatus": "DONE"
       }

You will get a response showing the training status, which is shown here:

      DONE

Note that if your data does not have any correlation, then you will see a very high value of meanSquaredError.

Before we add Triggers to Salesforce, make sure that Predicted_Probability field is created in the Salesforce. To create a field in Salesforce follow the following steps:

The trigger code uses Apex, which is similar to JAVA provided by the Salesforce platform to write business logic. For the purposes of demonstration, we will keep the code very simple:

      //Trigger makes an API call to Google Prediction API 
      to predict opportunity probability
      //Please note that this trigger is written for demonstration 
      purpose only and not bulkified or batched 
      trigger opportunityPredictor on Opportunity (after insert) {
        if(trigger.isinsert && trigger.isAfter){
          OpportunityTriggerHelper.predictProbability
          (trigger.new[0].Id);
        }
      }

The Apex class that is invoked from the trigger is as follows:

SETUP | Develop | Apex Classes

      //Apex Class to make a Callout to Google Prediction API
      public with sharing class opportunityTriggerHelper{
        @future(callout=true)
        public static void predictProbability(Id OpportunityId){
          Opportunity oppData = [Select Id,Amount,Type,
          Predicted_Probability__c from Opportunity where Id =
          :OpportunityId];
          HttpRequest req = new HttpRequest();
          req.setEndpoint('callout:Google_Auth');
          req.setMethod('POST');
          req.setHeader('content-type','application/json');
          //Form the Body
          PredictionAPIInput apiInput = new PredictionAPIInput();
          PredictionAPIInput.csvData csvData = 
          new PredictionAPIInput.csvData();
          csvData.csvInstance = new list<String>{
            oppData.Type,String.valueof(oppData.Amount)};
          apiInput.input = csvData;
          Http http = new Http();
          req.setBody(JSON.serialize(apiInput));
          HTTPResponse res = http.send(req);
          System.debug(res.getBody());
          if(res.getStatusCode() == 200){
            Map<String, Object> result = (Map<String, Object>)
            JSON.deserializeUntyped(res.getBody());
            oppData.Predicted_Probability__c = 
            Decimal.valueof((string)result.get('outputValue'));
            update oppData;
          }
        }
      }

The apex class for parsing the JSON is as follows:

       public class PredictionAPIInput {
         public csvData input;
         public class csvData {
           public String[] csvInstance;
         }
       }

To simplify the authentication, we will use a named credential in Salesforce and auth settings to keep it configurable. Note that this is not scalable, but it's a quick way to integrate Salesforce with Google for the purposes of demonstration only. You can use a service account or set up a full OAuth 2.0 if you are considering a scalable approach.

The steps to authorize Salesforce to access the Google Prediction API are as follows:

Once an OAuth consent screen is created, create a web application and note the Consumer Secret and Consumer Key. This will be used in the Salesforce Auth. Provider screen:

Select the Provider Type as Google. The following screenshot shows the form. Note that we use the Consumer Key and Consumer Secret from step 1 as input to the Auth. Provider form:

The following screenshot shows the saved Auth. Provider record. Note the Callback URL as it will be fed back to the Google OAuth consent screen:

The API that the Apex trigger code hits is as follows:

https://www.googleapis.com/prediction/v1.6/projects/learned-maker-155103/trainedmodels/opportunity-predictor/predict

To test, create the Salesforce new record and add fields such as type and amount and monitor the custom probability field on the Salesforce opportunity record.

To switch to the Salesforce Lightning experience, consider the following screenshot:

The following screenshot shows the results obtained in Lightning Experience, and, clearly, the Predicted_Probability field is populated:

The preceding approach is not scalable, while it serves as a great experiment to understand the fundamentals of a machine learning process.

From the previous experiment, the following are the conclusions: