Name: SAP Data Intelligence ML Scenario Manager (08) Creating REST API Inference Pipelines
Uploaded: 2023-9-4
Duration: 473 s

Share feedback

<p>Planned maintenance of Practice Systems</p>

Planned maintenance of Practice Systems

Why create an SAP account?

Enhance your learning experience

SAP Learning

Subscribe now

Learn more

Live Sessions

Hands-on Practice

Certification

My Learning

Ready to start learning?

<div><div>In this eighth of a nine part video series regarding the SAP Data Intelligence Machine Learning Scenario Manager, Tahir Hussain Babar (Bob) shows how to configure graphical pipelines, built from templates, to serve REST APIs.<br><br>0:00 - Introduction<br>1:00 - Create Python Consumer pipeline<br>1:30 - Pipeline review<br>4:00 - Configure operator<br>5:50 - Tag group<br>6:40 - OpenAPI Server<br><br><a href="https://sap.to/6058KrmVI" rel="nofollow noopener noreferrer" target="_blank">https://sap.to/6058KrmVI</a><br><br>Please note:<br>                     This video was originally published on the SAP HANA Academy YouTube Channel                      and therefore may contain references to SAP HANA Academy and YouTube.                      The tech world is always evolving and the SAP HANA Academy YouTube channel                      is set to close on December 31, 2023.                      At that time, references will no longer be valid                      and will gradually be removed when the videos are updated.<br>Also, this video includes automatically generated captions                      and therefore might misrepresent the spoken content or display incorrect product names.</div></div>

SAP Data Intelligence ML Scenario Manager (08) Creating REST API Inference Pipelines

Welcome to the SAP HANA Academy. My name's Bob, and in this video series, we'll be looking at SAP Data Intelligence. In this video series, we'll be focusing on using the Machine Learning Scenario Manager. And what we'll cover is how to create predictions within the Machine Learning Scenario Manager and then expose them so that they can be accessed via an API. In this video, we're going to be looking at creating pipelines that can enable us to utilize REST APIs to access our predictions. In the previous video we looked at executing a pipeline which enables us to train a model and then that model and its associated metrics were saved into our machine learning scenario. Now what we're going to do in this video is set up another pipeline to surface the model as a REST API for inference, which means it will make predictions. So firstly we'll need to create ourselves a pipeline in our machine learning scenario and we'll call this 20 apply rest API SHA. We'll need to select our template and this time we're going to choose a python consumer. Then I'll click on create. It will take a few seconds to prepare the pipeline with that template, and we should see we've got around seven or eight operators in this pipeline. So what I'll do is I'll go through a high-level overview of each of the pieces or operators within this pipeline. As you can imagine, this follows our training pipeline. Now this first operator, the Artifact Consumer, it loads the trained model from our machine learning scenario. To do this we'll be using a constant generator which simply emits a constant string into your pipeline. And as you can see here, the artifact actually is our model ID. The output from that operator will then be converted, as you can see here, it will be converted to a message. The next operator is an artifact consumer, and this is essentially going to receive the ID from the artifact and simply outputs its metadata. One thing to note here is that it's normally followed by an operator to retrieve an artifact file from your semantic data lake. Now when it comes to configuration, there's nothing really needed to be configured here. All we need to do is specify it. Now that we've actually got our ArtifactConsumer sorted and it connects to our Artifact ID, all we'll do then is perform some formatting, and then we'll use the ReadFile operator, which again is expected after using the ArtifactConsumer. Now the two most important operators are at the end. What you'll see is that we have an OpenAPI servlo operator which creates the REST API and also a Python 36 inference operator which ties everything together. Essentially what it will do is it will receive the input from the REST API call, for us it's the half marathon time and then it will use the loaded model to create the prediction So, we will get the normal drivetrain from this wikipedia. So, there is the test. We will then import the data from the start, and then we will start the prova test on this test. Now, at the top of the code, in the onModel function, we'll just need to replace the model name. This will recreate the model that was saved earlier. So what we'll need to do firstly is do an import of Pickle, of course. We're using Pickle to retrieve the model, and we're loading it in the form of a blob format. In terms of the code, we've got a few global variables to keep track of our model status, and we've set them at the top. And then the next step is to validate that the import data is correctly in JSON format. Again, the next step is to import that model using Pickle, and we've also got a message to indicate that it was received and is ready. And although we've added some global variables at the top of the code, what we'll need to do is add a variable to store our prediction. So what we'll do is we'll do this on the onInput function, and we'll add the following line. So firstly we'll add prediction equals none, and then below the existing comment which is obtain your results we just need to add some syntax to extract the input data which is our half marathon time and then a line of code which will carry out the prediction. If we look further down the code, we just need to return the actual prediction. And we can do this within if success. So all we need to do is output the marathon minutes prediction and round that value in JSON format like so. Now there's nothing else we need to change. All we need to do is close this editor window, and again just like before when we did the training pipeline we need to assign the docket image to this Python 36 inference operator. So again what we'll do is right click on that Python operator and we'll select the group, and then we just need to add the tag just like we did before. So I'll go to my configuration and we just need to select our tag. So from the drop-down, again, I'll select MarathonTimes underscore SHA. When we've selected it, essentially all our modifications have been implemented. So now the Python operator and the OpenAPI servlo are going to run in a loop, which means I can send a number of half marathon minutes and retrieve back a prediction about the full marathon, how long it will take to run that full marathon. The last step is provided by the OpenAPI servlo and this essentially creates the REST API. Now we've covered this in depth in other videos in the series but if you go to configuration parameters the main thing that you would have to change is your base path which would be your endpoints, your URL in which you're going to access your OpenAPI. But for us, we don't actually need to change anything here. Now what we want is that the pipeline will be running constantly, waiting to be called for a prediction. In order to do this, we have to deploy the pipeline. So before we get to that stage, what we'll do is we'll save our pipeline. And if we go back to our scenario within the Machine Learning Scenario Manager, what we'll do then in the next video is look at deploying and executing this pipeline.