AI Deploy - Tutoriel - Déployer une app Gradio pour de la reconnaissance de schémas

Objectif

L'objectif de ce tutoriel est de déployer une application de reconnaissance de dessins en utilisant un modèle entraîné.

Le cas d'usage est la reconnaissance de chiffres manuscrits, basée sur le jeu de données MNIST.

Pour cela, vous allez utiliser Gradio, une bibliothèque Python open source qui permet d'exposer et d'utiliser rapidement des modèles de Machine Learning. Vous apprendrez également à construire et à utiliser une image Docker personnalisée pour une application Gradio.

Aperçu de l'app :

Prérequis

• Un projet AI Deploy créé au sein d'un projet Public Cloud dans votre compte OVHcloud.
• Un utilisateur pour AI Deploy.
• Docker installé sur votre ordinateur local.
• Quelques connaissances sur la construction d'images et les Dockerfile.
• Vous devez également avoir suivi les étapes du notebook Image Classification with MNIST dataset du dépôt GitHub. Vous pourrez ainsi entraîner et sauvegarder votre modèle. Pour lancer ce notebook et l'exécuter, reportez-vous à cette documentation.

En pratique

Vous allez suivre différentes étapes pour construire votre application Gradio.

• Plus d'informations sur les capacités de Gradio sont disponibles ici.
• Le lien direct vers le fichier Python complet est disponible ici.

Nous allons ici principalement voir comment écrire le code app.py, le fichier requirements.txt et le Dockerfile. Si vous souhaitez voir le code complet, reportez-vous au dépôt GitHub.

Écrire l'application Gradio

Créez un fichier Python nommé app.py.

À l'intérieur de ce fichier, importez les modules requis.

import gradio as gr
import tensorflow as tf
import cv2

Définissez les éléments qui composent l'app AI Deploy : titre, en-tête et références.

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)."

Spécifiez la taille des images en entrée et les noms des classes.

img_size = 28

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

Chargez le modèle précédemment entraîné pour la classification des chiffres manuscrits.

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

Créez la fonction qui reconnaît le chiffre écrit.

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)

Lancez l'interface Gradio.

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)

Écrire le fichier requirements.txt de l'application

Le fichier requirements.txt nous permettra d'obtenir tous les modules nécessaires au fonctionnement de notre application. Ce fichier sera utile lors de l'écriture du Dockerfile.

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

Écrire le Dockerfile de l'application

Votre Dockerfile doit commencer par l'instruction FROM indiquant l'image parente à utiliser. Dans notre cas, nous choisissons de partir de l'image python:3.7 :

FROM python:3.7

Créez le répertoire personnel et ajoutez-y vos fichiers :

WORKDIR /workspace
ADD . /workspace

Installez les modules Python nécessaires à l'aide d'une commande pip install ... avec le fichier requirements.txt qui contient tous les modules :

RUN pip install -r requirements.txt

Attribuez les droits d'accès corrects à l'utilisateur ovhcloud (42420:42420) :

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

Définissez votre commande de lancement par défaut pour démarrer l'application :

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

Construire l'image Docker depuis le Dockerfile

Depuis le répertoire contenant votre Dockerfile, exécutez l'une des commandes suivantes pour construire l'image de votre application :

# 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 .

• La première commande construit l'image en utilisant l'architecture par défaut de votre système. Cela peut fonctionner si votre machine utilise déjà l'architecture linux/amd64, qui est requise pour exécuter des containers avec nos produits AI. Cependant, sur des systèmes avec une architecture différente (par exemple ARM64 sur Apple Silicon), l'image résultante ne sera pas compatible et ne pourra pas être déployée.

• La seconde commande cible explicitement l'architecture linux/amd64 afin de garantir la compatibilité avec nos services AI. Elle nécessite buildx, qui n'est pas installé par défaut. Si vous n'avez jamais utilisé buildx auparavant, vous pouvez l'installer en exécutant : docker buildx install

Envoyer l'image vers le registre partagé

Trouvez l'adresse de votre registre partagé en lançant cette commande :

ovhai registry list

Connectez-vous au registre partagé avec vos identifiants habituels d'utilisateur AI Platform :

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

Envoyez l'image créée vers le registre partagé :

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

Lancer l'app AI Deploy

La commande suivante démarre une nouvelle app AI Deploy exécutant votre application Gradio :

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

Pour lancer votre app Gradio, vous devez attacher 1 volume à cette app AI Deploy. Il contient le modèle que vous avez entraîné précédemment dans la partie "Save and export the model for future inference" du notebook.

Si vous souhaitez que votre app AI Deploy soit accessible sans avoir besoin de vous authentifier, spécifiez-le comme suit.

Aller plus loin

• Vous pouvez imaginer déployer un modèle d'IA avec un autre outil : Flask. Reportez-vous à ce tutoriel.
• Vous souhaitez utiliser Streamlit pour créer une app de classification audio ? C'est par ici.

Pour une formation ou une assistance technique sur la mise en œuvre de nos solutions, contactez votre commercial ou consultez la page Professional Services pour obtenir un devis et faire analyser votre projet par nos experts.

Votre avis nous intéresse !

N'hésitez pas à nous faire part de vos questions, retours et suggestions pour améliorer le service :

• Sur le serveur Discord OVHcloud