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

Last updated 31st January, 2023.

Objective

The purpose of this tutorial is to deploy an application for sketch recognition using a trained model.

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

In order to do this, you will use Gradio, an open-source Python library which 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:

Requirements

• Access to the OVHcloud Control Panel.
• An AI Deploy project created inside a Public Cloud project in your OVHcloud account.
• A user for AI Deploy.
• Docker installed on your local computer.
• Some knowledge about building image and Dockerfile.
• You also should have followed the steps of the Image Classification with MNIST dataset notebook from the GitHub repository. You will be able to train and save your model. To launch this notebook and run it, please refer to this documentation.

Instructions

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

• More information about Gradio capabilities can be found here.
• Direct link to the full Python file can be found here here.

Here we will mainly discuss on 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 images size and the classes names.

img_size = 28

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

Load the previously trained model for handwritten digits classification.

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

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

Launch the following command from the Dockerfile directory to build your application image:

docker build . -t gradio_app:latest

Push the image into the shared registry

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

ovhai registry list

Log in on the shared registry with your usual OpenStack 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>/:/workspace/model:RO \
      <shared-registry-address>/gradio_app:latest

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.

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

Go further

• You can imagine deploying an AI model with an other tool: Flask. Refer to this tutorial.
• Do you want to use Streamlit to create a audio classification app? Here it is.

Feedback

Please send us your questions, feedback and suggestions to improve the service:

• On the OVHcloud Discord server

These guides might also interest you...