Name: SAP AI ; Predictive Maintenance ; Configurations
Uploaded: 2023-9-7
Duration: 618 s

Share feedback

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

Planned maintenance of Practice Systems

Why create an SAP account?

Enhance your learning experience

SAP Learning

Choose your subscription

Manage your subscription

Live Sessions

Hands-on Practice

Certification

My Learning

Ready to start learning?

<div><div><div>In this playlist by Tahir Hussain Babar (Bob), from the SAP HANA Academy, we use SAP Artificial Intelligence to build a Deep Learning model on Acoustical Sound for Predictive Maintenance with SAP AI Core. In this video, we look at creating dataset artifacts in ML Operations in SAP AI Launchpad. We also look at preparing our model for execution, the python libraries needed, and then look at listing scenarios, connecting datasets to AI Core and creating configurations.<br><br>00:00 - Intro<br>01:12 - Connecting AI Core to S3 Bucket<br>03:45 - Loading Libraries for Training Model<br>03:59 - Extra Base URL for Training<br>05:17 - Scenarios<br>06:42 - Registering Datasets as Artifacts<br>08:23 - Creating Configurations<br><br>SAP AI in BTP: <a href="https://www.sap.com/products/artificial-intelligence.html" rel="nofollow noopener noreferrer" target="_blank">https://www.sap.com/products/artificial-intelligence.html</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></div>

SAP AI ; Predictive Maintenance ; Configurations

Welcome to the SAP HANA Academy. My name is Bob, and in this video series, we'll be looking at SAP Artificial Intelligence. In this video playlist we'll be building a deep learning model on acoustical sound for predictive maintenance with SAP AI Core. And in this video we're going to be looking at a range of subjects including connecting our S3 buckets to SAP AI Core. We'll also look at scenarios and also configurations. In the previous video we looked at the concept of our workflow templates and also our serving templates. We finished off with making sure that the status of these was healthy. So what we need to do is set up now configurations in order for us to create what are called executions. To do that there are a few tasks that we have to do before we actually build the configuration. The first thing we have to do is connect our S3 bucket to SAP AI Core. So if I go to a command line, if you remember in one of the first videos, we loaded some sound files into our S3 bucket. They're in a folder called sound and within data, you'll see that we've got three categories of those sound files. So if I go into the OK folder, these are all the sound files that are OK. So we have to connect this S3 bucket to our SAP AI Core. By doing this we'll enable our Docker training image to be able to access those sound files. So this is what the code looks like. Again you can see on line 2 that we're connecting to a JSON file which contains our key to our S3 bucket. And we set this up in our onboarding series where we actually created an object store within SAP Business Technology Platform. So after we've created the variable for that ServiceKey.json file, the second command will load that ServiceKey file, and then we'll have a dictionary called default-secret, which will define the connection parameters of our S3 bucket. So we have the name of the connection and we have all the information which of course comes from that JSON file. Here we're including the path prefix although this could actually be in that JSON file as well and as we know within the bucket we have that folder called sound. The last part of this cell will be to call the API. And we're doing this because we want to assign this object store secret to our resource group called sound. So we'll have a connection called default secret and it will be assigned to this resource group called sound. So I'll run this command to create that object store secret. And here we can see that the secret has indeed been created. So how do we know it's been created? Well of course here within the Jupiter notebook we can run a command that can retrieve our list of object store secrets within the resource group sound. So here you can see all those connection parameters. So now that we've actually connected S3 to our SEP AI core, what we can do is create a configuration for our training model. Before we do that we'll need to load some libraries that we're going to be using in order to set this piece up. So I'll create a header, and then I'll load the libraries onto my cell. I'll execute them. And when we've done that, what we'll want to do is create what's called an extra base URL, specifically for when we're training our model, and it will apply to this resource group. So of course we create a variable at the top, which is our resource group. And just like before, we'll call that AIC service key, which of course relates to the key in here, which connects to SAP AI Core. And of course I have to make sure that the folder structure matches like so. And then we'll create that AI instance. Now we're going to call it ai underscore api underscore lm and it will be attached to that resource group, which of course is called sound. And we'll use that in a few minutes when we're setting up our configurations. Now before we do that, let's investigate the concepts of scenarios. So if I go back into my SAP AI Launchpad, and we go to our workspaces, you can see here we've selected our sound resource group. Now if I go to my machine learning operations and we click on overview, you'll notice that we've got here some executables and some scenarios. We know that these scenarios come from our workflow YAML files. We've got one for sound and one for image that we did in the previous playlist. And these will relate to these training workflow files. So if I go into this file and we look for scenario, you'll see that we've got that scenario ID. So that's why those objects are appearing in the SAP AI Launchpad. And when it comes to creating our configurations here in our Jupyter Notebook, we'll be utilizing these scenarios. Or more specifically the sound scenario. We can create the configurations here, but we're going to create them in Jupyter Notebooks and we'll refer to this scenario. So of course, what we might want to do is list those scenarios here just to make sure that we can access them in our Jupyter Notebook. So I've got some code here that I'll paste in which will retrieve the scenario as well as the scenario ID using that new base URL which of course is attached to our resource group. So what we should do is output the two scenarios that you see here in our Jupyter Notebook. So I'll execute that code. And here we have those two scenarios. So the next step will be to register the data set within the SRE bucket as an artifact within SAP AI Core. And there's a few steps within this cell. So the second line, we're going to create a variable for that local version of our training workflow file, which is a duplicate of the one that is in the GitHub repository. So this is that local version. The next part of the cell will utilize a function called SafeLoad. Now this is a YAML method which will load a file. The next thing we'll do is we'll load the scenario ID from that YAML file. And then we'll set what's called our Artifact Configuration, which is basically the SRE connection. And we'll give it a description and we'll link it to that scenario ID. Next we'll store the artifact response to retrieve the ID for that specific training connection. And we'll check the message to see if it contains that expected string. So as we can see we get the response that the artifact has been registered for that specific scenario. Which of course links it to that S3 bucket. And again that S3 bucket is where the data is. So because we've created an artifact we can go ahead and check within the SCP AI Launchpad to see if it exists. So I'll go back to the Launchpad. Of course we haven't created the configuration yet, but we have created a data set and here we can see the name of our data set and the associated description that we just added. You can create the configuration here in the Launchpad, but we're going to create it here within our Jupyter Notebook. You can see a configuration as pulling all the pieces together before you execute your training of your model. So this is the code that is involved within one of those configurations. So we start with two lines at the top which will define some variables. One for the input artifact name and one for the executable name. We'll then create a dictionary with the key and the artifact ID. And then we'll create another dictionary which will contain our training configuration. So you'll see it has some options such as a configuration name called Sound Training Configuration and it will have the scenario ID, executable ID and any parameters. We'll then store the configuration response, which will be used when we create the execution, and we'll just print out confirmation. Here we can see we've got our configuration ID and confirmation that the configuration was created. If we go back to the SAP AI Launchpad and go back to configurations, here we can see that configuration that we've just created. And if I expand you can see we've got various artifacts assigned which will include the data set. In the next video, we're going to look at creating executions, which we can do here within the configuration. We'll be looking at creating those executions programmatically from our Jupyter Notebook. We'll be looking at creating those executions programmatically from our Jupyter Notebook. Jupyter Notebook.