Comment créer une application complète de vision par ordinateur en quelques minutes avec seulement deux fonctions Python

Traducteur | Li Rui

Contrôleur | Chonglou

Cet article présente d'abord brièvement les exigences de base des applications de vision par ordinateur. Ensuite, Pipeless, un framework open source, est présenté en détail, qui offre une expérience de développement sans serveur pour la vision par ordinateur embarquée. Enfin, un guide détaillé étape par étape est fourni qui montre comment créer et exécuter une application simple de détection d'objets à l'aide de quelques fonctions Python et d'un modèle.

Créer des applications de vision par ordinateur

Une façon de décrire la « vision par ordinateur » est de la définir comme « le domaine de la reconnaissance et du traitement d'images qui utilise des caméras et des techniques algorithmiques ». Cependant, cette définition simple ne satisfait peut-être pas pleinement à la compréhension du concept par les gens. Par conséquent, afin de mieux comprendre le processus de création d’applications de vision par ordinateur, nous devons considérer les fonctionnalités que chaque sous-système doit implémenter. Le processus de création d'applications de vision par ordinateur implique plusieurs étapes clés, notamment l'acquisition d'images, le traitement d'images, l'extraction de caractéristiques, la reconnaissance d'objets et la prise de décision. Premièrement, les données d’image sont acquises via une caméra ou un autre dispositif d’acquisition d’images. Les images sont ensuite traitées à l'aide d'algorithmes, comprenant des opérations telles que le débruitage, l'amélioration et la segmentation pour une analyse plus approfondie. Au cours de l'étape d'extraction des caractéristiques, le système identifie les caractéristiques clés de l'image, telles que

Afin de traiter un flux vidéo de 60 ips en temps réel, chaque image doit être traitée en 16 millisecondes. Ceci est généralement réalisé grâce à des processus multithread et multi-traitement. Parfois, il est même nécessaire de commencer le traitement de l'image suivante avant que la précédente ne soit terminée pour garantir un traitement très rapide des images.

Pour les modèles d'intelligence artificielle, heureusement, il existe actuellement de nombreux excellents modèles open source, donc dans la plupart des cas, il n'est pas nécessaire de développer votre propre modèle à partir de zéro, il suffit d'affiner les paramètres pour répondre au cas d'utilisation spécifique. Ces modèles exécutent des inférences sur chaque image, effectuant des tâches telles que la détection d'objets, la segmentation, l'estimation de pose, etc.

• Runtime d'inférence : Le runtime d'inférence est responsable du chargement du modèle et de son exécution efficace sur différents appareils disponibles (GPU ou CPU).

Pour garantir que le modèle puisse s'exécuter rapidement pendant le processus d'inférence, l'utilisation du GPU est essentielle. Les GPU peuvent gérer des ordres de grandeur plus d'opérations parallèles que les CPU, en particulier lors du traitement de grandes quantités d'opérations mathématiques. Lors du traitement des images, vous devez prendre en compte l'emplacement mémoire où se trouve l'image. Vous pouvez choisir de la stocker dans la mémoire GPU ou dans la mémoire CPU (RAM). Cependant, la copie d'images entre ces deux mémoires différentes peut entraîner des opérations plus lentes, notamment lorsque la taille de l'image est grande. Cela signifie également que les choix de mémoire et la surcharge de transfert de données doivent être pris en compte pour obtenir un processus d'inférence de modèle plus efficace.

Le pipeline multimédia est un ensemble de composants qui extraient un flux vidéo d'une source de données, le divisent en images, puis l'utilisent comme entrée dans le modèle. Parfois, ces composants peuvent également modifier et reconstruire le flux vidéo pour le transfert. Ces composants jouent un rôle clé dans le traitement des données vidéo, garantissant que le flux vidéo peut être transmis et traité efficacement.

• Gestion des flux vidéo : les développeurs peuvent souhaiter que les applications soient capables de résister à l'interruption des flux vidéo, à la reconnexion, d'ajouter et de supprimer dynamiquement des flux vidéo, de gérer plusieurs flux vidéo simultanément, et bien plus encore.

Tous ces systèmes doivent être créés ou intégrés au projet et, par conséquent, le code doit être maintenu. Cependant, le problème rencontré est que vous finissez par conserver une grande quantité de code qui n'est pas spécifique à l'application, mais plutôt un sous-système qui entoure le code spécifique au cas réel.

Pipeless Framework

Pour éviter de créer tout ce qui précède à partir de zéro, vous pouvez utiliser le framework Pipeless à la place. Il s'agit d'un framework open source pour la vision par ordinateur qui permet certaines fonctionnalités spécifiques à un cas et est capable de gérer d'autres choses.

Le framework Pipeless divise la logique de l'application en "étapes", dont l'une est comme une micro-application d'un modèle unique. Une étape peut inclure un prétraitement, l'exécution d'une inférence à l'aide de l'entrée prétraitée et le post-traitement de la sortie du modèle pour une action. Vous pouvez ensuite enchaîner autant d'étapes que vous le souhaitez pour constituer une application complète, même en utilisant plusieurs modèles.

Pour fournir la logique de chaque étape, ajoutez simplement une fonction de code spécifique à l'application et Pipeless se charge de l'appeler en cas de besoin. C'est pourquoi Pipeless peut être considéré comme un framework qui offre une expérience de développement de type serveur pour la vision par ordinateur embarquée et fournit certaines fonctionnalités sans se soucier du besoin de sous-systèmes supplémentaires.

Une autre fonctionnalité intéressante de Pipeless est la possibilité d'automatiser le traitement des flux vidéo en ajoutant, supprimant et mettant à jour dynamiquement des flux vidéo via CLI ou API REST. Vous pouvez même spécifier une politique de redémarrage, indiquant quand le traitement du flux vidéo doit être redémarré, s'il doit être redémarré après une erreur, etc.

Enfin, pour déployer le framework Pipeless, il suffit de l'installer sur n'importe quel appareil et de l'exécuter avec vos fonctions de code, que ce soit dans une machine virtuelle de cloud computing ou en mode conteneurisé, ou directement dans un appareil edge tel que Nvidia Jetson, Raspberry, etc.

Création d'une application de détection d'objets

Voici un aperçu détaillé de la façon de créer une application de détection d'objets simple à l'aide du framework Pipeless.

La première étape est l'installation. Le script d'installation rend l'installation très simple :

Curl https://raw.githubusercontent.com/pipeless-ai/pipeless/main/install.sh | bash

Maintenant, il faut créer un projet. Un projet Pipeless est un répertoire contenant des étapes. Chaque étape se trouve dans un sous-répertoire, et dans chaque sous-répertoire, un fichier contenant des hooks (fonctions de code spécifiques) est créé. Le nom fourni pour chaque dossier d'étape est le nom de l'étape qui doit être indiqué ultérieurement dans la boîte Pipeless lorsque vous souhaitez exécuter cette étape pour le flux vidéo.

pipeless init my-project --template emptycd my-project

Ici, le modèle vide indique à la CLI de créer uniquement le répertoire, si aucun modèle n'est fourni, la CLI posera quelques questions pour créer la scène de manière interactive.

Comme mentionné ci-dessus, il faut désormais ajouter une étape au projet. Téléchargez un exemple de scène depuis GitHub à l'aide de la commande suivante :

wget -O - https://github.com/pipeless-ai/pipeless/archive/main.tar.gz | tar -xz --strip=2 "pipeless-main/examples/onnx-yolo"

Cela créera un répertoire de scène onnx-yolo qui contient les fonctions de l'application.

Ensuite, vérifiez le contenu de chaque fichier d'étape, qui sont des hooks d'application.

Voici un fichier pré-process.py qui définit une fonction (hooks) qui accepte un cadre et une scène. Cette fonction effectue certaines opérations pour préparer les données d'entrée recevant les images RVB afin qu'elles correspondent au format attendu par le modèle. Ces données sont ajoutées à frame_data['interence_input'], qui sont les données que Pipeless transmettra au modèle.

def hook(frame_data, context):frame = frame_data["original"].view()yolo_input_shape = (640, 640, 3) # h,w,cframe = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)frame = resize_rgb_frame(frame, yolo_input_shape)frame = cv2.normalize(frame, None, 0.0, 1.0, cv2.NORM_MINMAX)frame = np.transpose(frame, axes=(2,0,1)) # Convert to c,h,winference_inputs = frame.astype("float32")frame_data['inference_input'] = inference_inputs... (some other auxiliar functions that we call from the hook function)

Il y a aussi le fichier process.json qui indique quel runtime d'inférence Pipeless utiliser (runtime ONNX dans ce cas), où trouver le modèle qu'il doit charger, et certains de ses paramètres facultatifs, tels que comme fournisseur_d'exécution à utiliser, c'est-à-dire CPU, CUDA, TensorRT, etc.

{ "runtime": "onnx","model_uri": "https://pipeless-public.s3.eu-west-3.amazonaws.com/yolov8n.onnx","inference_params": { "execution_provider": "tensorrt" }}

Enfin, le fichier post-process.py définit une fonction similaire à celle de pre-process.py. Cette fois, il accepte la sortie d'inférence que Pipeless stocke dans frame_data["inference_output"] et effectue l'opération d'analyse de cette sortie dans un cadre englobant. Plus tard, il dessine le cadre de délimitation sur le cadre et attribue finalement le cadre modifié à frame_data['modified']. De cette façon, Pipeless transmettra le flux vidéo fourni, mais avec des images modifiées, y compris des cadres de délimitation.

def hook(frame_data, _):frame = frame_data['original']model_output = frame_data['inference_output']yolo_input_shape = (640, 640, 3) # h,w,cboxes, scores, class_ids =  parse_yolo_output(model_output, frame.shape, yolo_input_shape)class_labels = [yolo_classes[id] for id in class_ids]for i in range(len(boxes)):draw_bbox(frame, boxes[i], class_labels[i], scores[i])frame_data['modified'] = frame... (some other auxiliar functions that we call from the hook function)

La dernière étape consiste à démarrer Pipeless et à fournir un flux vidéo. Pour démarrer Pipeless, exécutez simplement la commande suivante dans le répertoire my-project :

pipeless start --stages-dir .

Une fois exécuté, le flux vidéo de la webcam (v4l2) sera fourni et la sortie sera affichée directement sur l'écran. Il convient de noter qu'une liste des étapes que le flux vidéo exécute en séquence doit être fournie. Dans ce cas, ce n'est que l'étape onnx-yolo :

pipeless add stream --input-uri "v4l2" --output-uri "screen" --frame-path "onnx-yolo"

Conclusion

Créer une application de vision par ordinateur est une tâche complexe car de nombreux facteurs et sous-systèmes doivent être implémentés autour d'elle. Avec un framework comme Pipeless, la mise en route ne prend que quelques minutes, ce qui vous permet de vous concentrer sur l'écriture de code pour des cas d'utilisation spécifiques. De plus, les « étapes » Pipeless sont hautement réutilisables et faciles à entretenir, la maintenance sera donc facile et pourra être répétée très rapidement.

Si vous souhaitez participer au développement de Pipeless, vous pouvez le faire via son dépôt GitHub.

Tiginal Titre: Créez une application complète de vision par ordinateur en quelques minutes avec seulement deux fonctions Python, auteur: Miguel Angel Cabrera

link: https: //m.sbmmt.com/link/e26dbb5b1843bf566ea7ec757f3325c4