AI Deploy - Tutoriel - Créer un service web pour reconnaître la langue des signes avec YOLOv7

Objectif

L'objectif de ce tutoriel est de montrer comment déployer un service web permettant de reconnaître les lettres de la langue des signes américaine à l'aide du modèle YOLOv7.

Pour cela, vous allez utiliser Streamlit, un framework Python qui transforme des scripts en application web partageable. Vous apprendrez également à construire et à utiliser une image Docker personnalisée pour une application Streamlit.

Pour plus d'informations sur la façon d'entraîner YOLOv7 sur un jeu de données personnalisé, reportez-vous à la documentation suivante.

Voici un aperçu de l'app de reconnaissance de la langue des signes :

Prérequis

• Un projet AI Deploy créé au sein d'un projet Public Cloud
• Un utilisateur pour AI Deploy
• Docker installé sur votre ordinateur local
• Quelques connaissances sur la construction d'images et les Dockerfile
• Vos poids obtenus après l'entraînement du modèle YOLOv7 sur le jeu de données ASL letters (reportez-vous à la partie "Export trained weights for future inference" du notebook pour YOLOv7

En pratique

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

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

Nous allons ici principalement voir comment écrire le code main.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 Streamlit

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

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

import streamlit as st
from PIL import Image
import numpy as np
import torch
import cv2
import io
import os

Chargez le modèle YOLOv7 et vos propres poids. Placez cette fonction en cache :

@st.cache
def load_model():

    custom_yolov7_model = torch.hub.load("WongKinYiu/yolov7", 'custom', '/workspace/asl-volov7-model/yolov7.pt')

    return custom_yolov7_model

Créez la fonction d'inférence pour obtenir la prédiction :

def get_prediction(img_bytes, model):

    img = Image.open(io.BytesIO(img_bytes))
    results = model(img, size=640)

    return results

Écrivez la fonction d'analyse d'image :

def analyse_image(image, model):

    if image is not None:

        img = Image.open(image)
        bytes_data = image.getvalue()
        img_bytes = np.asarray(bytearray(bytes_data), dtype=np.uint8)
        result = get_prediction(img_bytes, model)
        result.render()

        for img in result.imgs:
            RGB_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
            im_arr = cv2.imencode('.jpg', RGB_img)[1]
            st.image(im_arr.tobytes())

        result_list = list((result.pandas().xyxy[0])["name"])

    else:
        st.write("no asl letters were detected!")
        result_list = []

    return result_list

Définissez la fonction Python qui affiche les lettres et forme un mot :

def display_letters(letters_list):

    word = ''.join(letters_list)
    path_file = "/workspace/word_file.txt"
    with open(path_file, "a") as f:
        f.write(word)

    return path_file

Définissez le main et démarrez votre app :

if __name__ == '__main__':

    st.image("/workspace/head-asl-yolov7-app.png")
    st.write("## Welcome on your ASL letters recognition app!")

    model = load_model()

    img_file_buffer = st.camera_input("Take your picture in real time:")

    result_list = analyse_image(img_file_buffer, model)
    path_file = display_letters(result_list)

    if st.button("Clear result"):
        if os.path.isfile(path_file):
            os.remove(path_file)
            print("File has been deleted")
        else:
            print("File does not exist")

    if (os.path.exists(path_file)==True):
        with open(path_file, "r") as f:
            content = f.read()
            st.write(content)
            f.close()
    else:
        pass

Écrire le fichier requirements.txt de l'application

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

torchvision==0.14.0
numpy==1.23.4
pandas==1.5.1
matplotlib==3.6.2
pillow==9.3.0
opencv-python-headless==4.6.0.66
streamlit==1.14.0
tqdm==4.64.1
seaborn==0.12.1
scipy==1.9.3
ipython==8.6.0
psutil==5.9.4
pyyaml==6.0

É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 d'une image python:3.8 :

FROM python:3.8

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

WORKDIR /workspace
ADD . /workspace

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

RUN pip install -r requirements.txt

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

CMD [ "streamlit" , "run" , "/workspace/main.py", "--server.address=0.0.0.0" ]

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

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

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 yolov7-streamlit-asl-recognition:latest

# Build image targeting the linux/amd64 architecture
docker buildx build --platform linux/amd64 -t yolov7-streamlit-asl-recognition: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

Tester en local (optionnel)

Lancez la commande Docker suivante pour lancer votre application localement sur votre ordinateur :

docker run --rm -it -p 8501:8051 --user=42420:42420 yolov7-streamlit-asl-recognition:latest

Une fois démarrée, votre application devrait être disponible sur http://localhost:8501.

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 compilée vers le registre partagé :

docker tag yolov7-streamlit-asl-recognition:latest <shared-registry-address>/yolov7-streamlit-asl-recognition:latest
docker push <shared-registry-address>/yolov7-streamlit-asl-recognition:latest

Lancer l'app AI Deploy

La commande suivante démarre une nouvelle app exécutant votre application Streamlit :

ovhai app run <shared-registry-address>/yolov7-streamlit-asl-recognition:latest \
	   --gpu 1 \
	   --default-http-port 8501 \
	   --volume asl-volov7-model@GRA/:/workspace/asl-volov7-model:RO

Aller plus loin

• Vous pouvez imaginer déployer une app utilisant des modèles YOLO avec un autre framework Python : Flask. Reportez-vous à ce tutoriel.
• N'hésitez pas à utiliser Streamlit pour d'autres tâches d'IA ! Déployez une app Speech-to-Text 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.