Name: SAP AI ; Defect Detection ; Docker Training Image Build & Push
Uploaded: 2023-9-7
Duration: 451 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 Image Segmentation Model which will help us perform automated Defect Detection on images of products. In this video, we at the building and pushing Docker images; focusing on the training model image.<br><br>00:00 - Intro<br>00:58 - "Building" the training model docker image locally<br>04:44 - "Pushing" the training model docker image to the repository<br>06:25 - Verifying docker image built successfully<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 ; Defect Detection ; Docker Training Image Build & Push

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 product images for automatic defect detection using SAP AI Core. And in this video, we'll be looking at building and pushing a Docker image. In the previous video we went through the three files that are needed in order to create our image for training our model. So we've put them in a folder called train images and we'll have to go into that folder when we build this docker image. You'll see that there's a docker file, a requirements.txt file and also a train.py file. To actually build the image we've already connected to our docker kli. We've logged in. So all we need to do is run the following command which is to do a docker build dash t and then this will be the name of the tag that we're building. So if I go back it'll be the name of our docker user. So I'll paste this here. Then we'll have a forward slash and then we've got our repository name. So for me we'll go back and we'll just copy it from here so you can see clearly what we're doing. So it's image-seg-train and the "-t-" means we're actually going to build a tag, so a version of this image. So we indicate that with a number, although this could be a string as well. So within tags and scans we will see this number or ID appear here. It doesn't actually have to be a number, so I'm just going to call mine simply 001 because it's the first time I'm building this. So we'll put a colon and 0.0.1 and we want it to apply to the files in the folder below, so we'll need to put a space dot. Again, this will make sure it uses that Dockerfile requirements.txt and the train.py. As you can imagine, the great thing about having this concept of tags and multiple versions is that you can test different scenarios. So the concept of tags can be very useful when using Docker. So what I'll do is I'll just click on return and the build will start. So as you can imagine it goes to the Dockerfile which tells it to go to the requirements, to load the various libraries, and then ultimately to run the Python required. So at the moment it's building that file based on the libraries that it needs. One thing to know is that you might have different commands to be executed in your requirements.txt file as I'm building this image in May 2022. So keep that in mind when you're performing your build. So the first few minutes it's extracting the various files, it's grabbing the files from the internet, and then you can see about halfway down from 2 out of 13 to 10 out of 13, it's running the various commands that you should recognize from that docker file. So here you can see it's copying the train file, it's installed things like tensorflow, it's gone to NVIDIA to install some resources for that. So the last step is that it's exporting what are called layers to the image. So it basically records any change to your image. You can also think of it as staging changes when you're using git. So for example you add a files change, then another one, and then another one. You will have these multiple layers. And the number of layers will normally depend on the number of commands that you have in your Dockerfile. So that's why if you look in the docker file you had around 13 commands and we have all of these layers where you can see here 2 out of 13 in the middle of the screen all the way up to 13 of 13 it's creating those various layers. So the build is finished, it's taken up a fair amount of size on my local image. So you can see of course the steps here which have executed and also on the right hand side you can see how long they took to execute. So I can execute a CLS. So now that we've got the image locally, what we can do of course is push that image to our repository. So it's a Docker push and the full name of the tag. So that's including of course that 001. So I will execute this command because it's going to take a while to push. Now going back to the concept of tagging. Now this is quite a useful feature because it means you can pull images from public repositories and then change the tags and then upload them. So for example, if you can't get your own image working, if you know someone who's got it working, as long as it's a public repository, you can grab a copy of that image and publish it to your own repository. You can see I'm only 20 meg through pushing a 2.5 gigabyte image. So what I'll do is with the Magica video, I will pause the recording and come back when we've got about five minutes to go. We're now quite near the end of the image being pushed. So while it's pushing, one more tip which I think you might find useful. Another useful feature of Docker is that instead of actually using other tools like Jupyter Notebooks to push your model to the Docker repository for it to train, you can also test the image locally. So there are commands, if you Google those commands, where you can run a command line to connect to your local Docker repository and execute, for example, the Python. So I was doing that when troubleshooting some issues. So it looks like the image has been pushed, so it should finish in a few seconds. So in this video we've looked at both building the image locally, and then pushing it to our Docker repository. Of course the ultimate test is to go into our Docker repository, go to that repository and we should see that tag which we've just pushed to the repository from our local machine. If you're having problems building your image, it is possible to download my image, re-tag it and upload it into your repository. So the image that I've just built should be available in my repository for a few months. In the next video, what we're going to do is because we've covered how the files work, we're going to quickly go through creating, building and pushing the serving image to our Docker repository. Good luck.