Skip to main content

AI Deploy - Tutorial - Deploy a Gradio app for sketch recognition

Stephanie R.
Updated

Learn how to deploy an application for sketch recognition using a trained model.

AI Deploy is covered by OVHcloud Public Cloud Special Conditions.

The use case is handwritten digit recognition, based on the MNIST dataset.

To do this, you will use Gradio, an open-source Python library that is a quick way to expose and use Machine Learning models. You will also learn how to build and use a custom Docker image for a Gradio application.

Overview of the app:

PaaS_AI_deploy_sketch01.png

 

Requirements

 

Instructions

You are going to follow different steps to build your Gradio application.

  • More information about Gradio's capabilities can be found here.
  • A direct link to the full Python file can be found here.

Here we will mainly discuss how to write the app.py code, the requirements.txt file, and the Dockerfile. If you want to see the whole code, please refer to the GitHub repository.

 

Write the Gradio application

Create a Python file named app.py.

Inside that file, import your required modules.

import gradio as gr
import tensorflow as tf
import cv2

Define the elements that make up the AI Deploy app: title, header, and references.

title = "Welcome on your first sketch recognition app!"

head = (
  "<center>"
  "<img src='file/mnist-classes.png' width=400>"
  "The robot was trained to classify numbers (from 0 to 9). To test it, write your number in the space provided."
  "</center>"
)

ref = "Find the whole code [here](https://github.com/ovh/ai-training-examples/tree/main/apps/gradio/sketch-recognition)."

Specify the input image's size and the class names.

img_size = 28

labels = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]

Load the previously trained model for handwritten digits classification.

To learn more about how you can save a model with TensorFlow, please refer to the part "Save and export the model for future inference" of the notebook.

Here you will use your trained model, then save it in an Object Storage container. Click here to learn more about Object Storage.

model = tf.keras.models.load_model("model/sketch_recognition_numbers_model.h5", compile=False)

Create the function that recognizes the written number.

def predict(img):

  img = cv2.resize(img, (img_size, img_size))
  img = img.reshape(1, img_size, img_size, 1)

  preds = model.predict(img)[0]

  return {label: float(pred) for label, pred in zip(labels, preds)}

label = gr.outputs.Label(num_top_classes=3)

Launch the Gradio interface.

interface = gr.Interface(fn=predict, inputs="sketchpad", outputs=label, title=title, description=head, article=ref)
interface.launch(server_name="0.0.0.0", server_port=8080)

 

Write the requirements.txt file for the application

The requirements.txt file will allow us to get all the modules needed to make our application work. This file will be useful when writing the Dockerfile.

gradio==3.0.10
tensorflow==2.9.1
opencv-python-headless==4.6.0.66

 

Write the Dockerfile for the application

Your Dockerfile should start with the FROM instruction indicating the parent image to use. In our case we choose to start from the python:3.7 image:

FROM python:3.7

Create the home directory and add your files to it:

WORKDIR /workspace
ADD . /workspace

Install your needed Python modules using a pip install ... command with the requirements.txt file which contains all modules:

RUN pip install -r requirements.txt

Give correct access rights to the ovhcloud user (42420:42420):

RUN chown -R 42420:42420 /workspace
ENV HOME=/workspace

Define your default launching command to start the application:

CMD [ "python3" , "/workspace/app.py" ]

 

Build the Docker image from the Dockerfile

From the directory containing your Dockerfile, run one of the following commands to build your application image:

# Build the image using your machine's default architecture
docker build . -t gradio_app:latest

# Build image targeting the linux/amd64 architecture
docker buildx build --platform linux/amd64 -t gradio_app:latest .

  • The first command builds the image using your system’s default architecture. This may work if your machine already uses the linux/amd64 architecture, which is required to run containers with our AI products. However, on systems with a different architecture (e.g. ARM64 on Apple Silicon), the resulting image will not be compatible and cannot be deployed.

  • The second command explicitly targets the linux/AMD64 architecture to ensure compatibility with our AI services. This requires buildx, which is not installed by default. If you haven’t used buildx before, you can install it by running: docker buildx install

The dot . argument indicates that your build context (place of the Dockerfile and other needed files) is the current directory.

The -t argument allows you to choose the identifier to give to your image. Usually image identifiers are composed of a name and a version tag <name>:<version>. For this example we chose gradio_app:latest.

 

Push the image into the shared registry

NOTE: The shared registry should only be used for testing purposes. Please consider creating and attaching your own registry. More information about this can be found here. The images pushed to this registry are for AI Tools workloads only, and will not be accessible for external uses.

Find the address of your shared registry by launching this command:

ovhai registry list

Log in on the shared registry with your usual AI Platform user credentials:

docker login -u <user> -p <password> <shared-registry-address>

Push the created image into the shared registry:

docker tag gradio_app:latest <shared-registry-address>/gradio_app:latest
docker push <shared-registry-address>/gradio_app:latest

 

Launch the AI Deploy app

The following command starts a new AI Deploy app running your Gradio application:

ovhai app run \
      --cpu 1 \
      --volume <my_saved_model>@<region>/model/:/workspace/model:RO \
      <shared-registry-address>/gradio_app:latest

--cpu 1 indicates that we request 1 CPU for that AI Deploy app.

If you want, you can also launch this AI Deploy app with one or more GPUs.

To launch your Gradio app, you need to attach 1 volume to this AI Deploy app. It contains the model that you trained before in part "Save and export the model for future inference" of the notebook.

--volume <my_saved_model>@<region>/:/workspace/saved_model:RO is the volume attached for using your pretrained model. This volume is read-only (RO) because you just need to use the model and not make any changes to this Object Storage container.

If you want your AI Deploy app to be accessible without the need to authenticate, specify it as follows.

Consider adding the --unsecure-http attribute if you want your application to be reachable without any authentication.

 

Go further

For more information and tutorials, please see our other AI & Machine Learning support guides or explore the guides for other OVHcloud products and services.

If you need training or technical assistance to implement our solutions, contact your sales representative or click on this link to get a quote and ask our Professional Services experts for a custom analysis of your project.

Related articles