Traitement des données non structurées du cloud à la périphérie
Les données non structurées représentent désormais environ 80 % des données que nous traitons, allant du texte et des images aux vidéos, à l’audio et à des formats plus complexes. À mesure que leur volume augmente, le besoin de meilleures méthodes pour les traiter et les analyser augmente également.
Lors d’un récent webinaire, Tim Spann, Principal Developer Advocate chez Zilliz, a partagé ses perspectives sur la gestion des données non structurées, en particulier depuis les environnements cloud jusqu’aux appareils en périphérie. Il a également souligné comment les bases de données vectorielles comme Milvus sont essentielles pour donner du sens à ces données.
Dans cet article, nous récapitulerons les principaux points de Tim, en abordant les défis liés au traitement des données non structurées et la manière dont les bases de données vectorielles ouvrent la voie. Nous examinerons également comment les appareils en périphérie alimentés par ces bases de données favorisent de nouvelles avancées en IA. Si vous souhaitez obtenir plus de détails, nous vous recommandons de regarder la rediffusion complète de la présentation de Tim sur YouTube.
Comprendre les données non structurées
Les données non structurées désignent des informations qui ne disposent pas d’un format ou d’un schéma prédéfini. Contrairement aux données structurées, qui sont soigneusement organisées dans des bases de données avec des champs et des formats spécifiques, les données non structurées sont brutes et non organisées. Elles incluent souvent :
Texte : E-mails, documents Word, publications sur les réseaux sociaux
Images : Photos, captures d’écran, diagrammes
Vidéos : Réunions enregistrées, vidéos de surveillance, contenu multimédia
Audio : Enregistrements vocaux, fichiers musicaux, podcasts
Avec l’essor du contenu numérique, les données non structurées ont connu une croissance exponentielle, offrant à la fois des opportunités et des défis aux organisations. Pour tirer parti de cette richesse d’informations, les entreprises peuvent :
Améliorer l’expérience client en analysant les interactions et les retours des clients
Améliorer l’efficacité opérationnelle grâce aux informations issues des données de capteurs et des journaux système
Stimuler l’innovation en exploitant le contenu multimédia pour le développement de produits
Les bases de données traditionnelles, conçues pour traiter des données structurées, peinent à gérer l’irrégularité des données non structurées, ce qui rend difficile la recherche, l’interrogation ou l’extraction d’informations significatives. C’est là que les bases de données vectorielles deviennent essentielles, en offrant une solution pour gérer et récupérer efficacement les informations non structurées.
Pourquoi utiliser une base de données vectorielle pour le traitement des données non structurées ?
Une base de données vectorielle est une base de données spécialisée conçue pour stocker, indexer et interroger des représentations vectorielles des données (également appelées embeddings vectoriels), souvent dérivées de données non structurées comme le texte, les images et l’audio. Ces bases de données permettent des recherches de similarité efficaces dans un espace de grande dimension, ce qui les rend idéales pour la recherche sémantique, le traitement du langage naturel (NLP), les systèmes de recommandation, les recherches d’images et la génération augmentée par récupération (RAG).
Les bases de données vectorielles telles que Milvus et Zilliz Cloud offrent un éventail de fonctionnalités au-delà des capacités de recherche haute performance, qui les rendent cruciales pour la gestion des données non structurées.
Au-delà de la recherche haute performance
Bien que les bases de données vectorielles soient souvent associées à des capacités de recherche de similarité rapide, leur utilité va bien plus loin. Elles fournissent d’autres fonctions essentielles qui garantissent la gestion et l’utilisation efficaces des données non structurées :
Opérations CRUD : Les bases de données vectorielles, comme les bases de données traditionnelles, vous permettent de créer, lire, mettre à jour et supprimer (CRUD) des données. Cela garantit que, malgré le travail avec des types de données complexes, les opérations de base restent intuitives et accessibles.
Fraîcheur des données : L’un des atouts majeurs des bases de données vectorielles est de garantir que vos données restent à jour. Dans des cas d’utilisation comme les systèmes de recommandation, maintenir les données à jour est essentiel pour générer des informations précises.
Persistance : Contrairement aux structures de données en mémoire, les bases de données vectorielles offrent un stockage persistant, ce qui signifie que vos données sont stockées en toute sécurité et accessibles même après les redémarrages du système.
Disponibilité : Les bases de données vectorielles maintiennent les données facilement accessibles pour les requêtes et la récupération en temps réel. Cela garantit que, même à mesure que vos données augmentent, vous pouvez toujours effectuer des recherches rapides et efficaces, permettant des décisions pilotées par l’IA sans délai.
Évolutivité : À mesure que le volume des données augmente, les bases de données vectorielles évoluent efficacement pour accompagner cette croissance sans dégradation des performances. C’est essentiel lors de la gestion de milliards de points de données non structurées.
Gestion complète des données
Au-delà des fonctions ci-dessus, les bases de données vectorielles fournissent des outils robustes pour gérer vos données non structurées, notamment l’ingestion des données, l’indexation et les requêtes, permettant une récupération et une analyse efficaces, même des plus grands ensembles de données. Des fonctionnalités telles que la sauvegarde et migration garantissent que vos données restent sécurisées et récupérables, faisant des bases de données vectorielles un choix fiable pour gérer les informations critiques.
Simplicité opérationnelle
Les bases de données vectorielles sont également conçues pour simplifier le déploiement et la gestion :
Déploiement cloud ou sur site : De nombreuses bases de données vectorielles conçues à cet effet sont polyvalentes et peuvent être facilement déployées sur des clouds publics ou sur une infrastructure sur site, garantissant une flexibilité selon les besoins de l’organisation.
Observabilité : De nombreuses bases de données vectorielles proposent des outils de surveillance pour suivre l’état et les performances de la base de données, permettant aux utilisateurs d’optimiser leurs systèmes de manière proactive.
Multi-tenancy : Les bases de données vectorielles comme Zilliz Cloud prennent en charge plusieurs utilisateurs ou applications, garantissant un accès sécurisé et une gestion isolée des données pour chaque locataire. Cela les rend idéales pour les déploiements à grande échelle où plusieurs équipes ont besoin d’environnements de données isolés.
Le rôle de Milvus dans la gestion des données non structurées
Milvus est une base de données vectorielle open source conçue pour stocker, indexer et récupérer efficacement des vecteurs de grande dimension à l’échelle du milliard, ce qui la rend idéale pour les cas d’utilisation impliquant l’IA et l’apprentissage automatique, tels que les systèmes de recommandation, la reconnaissance d’images ou la génération augmentée par récupération (RAG).
Milvus offre plusieurs options de déploiement pour répondre aux besoins diversifiés des clients.
Milvus open source : Open source, autogéré, et peut être hébergé sur n’importe quelle machine avec le soutien de la communauté. Milvus offre également plusieurs options de déploiement pour divers besoins et environnements, notamment Milvus Lite, Milvus Standalone et Milvus Distributed. Consultez la documentation Milvus pour plus de détails.
Zilliz Cloud: version entièrement gérée de Milvus, repensée pour le cloud et disponible sur les principaux clouds publics tels qu’AWS, GCP et Azure.
Zilliz BYOC: Milvus prêt pour l’entreprise pour les VPC privés et pouvant être déployé dans votre cloud privé virtuel.
Fig 1- Façons de déployer Milvus .png
Fig 1 : Façons de déployer Milvus
Fonctionnalités clés de Milvus
Milvus est conçu pour offrir de hautes performances et une grande évolutivité, avec des fonctionnalités telles que :
Figure- Fonctionnalités clés de Milvus .png
Figure : Fonctionnalités clés de Milvus
Multi-tenant : Milvus permet à plusieurs utilisateurs ou applications de travailler sur le même système sans interférer les uns avec les autres, en fournissant un accès sécurisé à des données isolées.
Calcul accéléré par matériel : optimisé pour exploiter du matériel comme les GPU, ce qui le rend plus rapide et plus efficace pour les tâches gourmandes en ressources telles que l’inférence de modèles d’IA.
Prise en charge des langages et des API : Milvus est très polyvalent, prenant en charge Python, Java, Golang, NodeJS, etc., ce qui le rend accessible à un large éventail de développeurs.
Architecture évolutive et élastique : Milvus est conçu pour gérer des besoins croissants en données. Il s’adapte automatiquement à la demande, garantissant que les performances restent optimales à mesure que les données augmentent.
Prise en charge d’index diversifiés : il prend en charge plusieurs types d’index, notamment HNSW, PQ, Binary et DiskANN, offrant une flexibilité dans la manière dont les données sont stockées et recherchées.
Cohérence ajustable : Milvus vous permet d’ajuster les niveaux de cohérence de vos données, vous permettant de trouver un équilibre entre performance et exactitude des données selon les besoins de l’application.
Pour des informations plus détaillées, consultez la documentation Milvus.
Technologies alimentant Milvus pour divers cas d’utilisation
Milvus s’appuie sur une suite de technologies répondant à différents types d’applications, garantissant performance, flexibilité et évolutivité dans divers environnements :
Figure- Technologies Milvus pour divers cas d’utilisation .png
Figure : Technologies Milvus pour divers cas d’utilisation
Types de calcul : Milvus est optimisé pour différents environnements matériels, notamment AVX512 (un ensemble d’instructions CPU pour le calcul à grande vitesse), Neon pour SIMD (Single Instruction, Multiple Data) et l’accélération GPU. Cela garantit que Milvus peut utiliser du matériel hautes performances pour fournir un traitement rapide et une évolutivité rentable.
Types de recherche : Milvus prend en charge un large éventail de méthodes de recherche, telles que top-K ANN (Approximate Nearest Neighbors) pour trouver les points de données les plus similaires, range ANN, les recherches sparse & dense et les recherches filtrées. Celles-ci nous permettent d’adapter la fonctionnalité de recherche aux besoins spécifiques de nos applications, qu’il s’agisse d’identifier des images, des vidéos ou du texte similaires.
Multi-tenant : Milvus prend en charge la gestion des collections et des partitions, permettant le multi-tenant. Cette fonctionnalité permet à différentes équipes ou applications de partager la même base de données sans interférer avec les données des autres, garantissant un traitement sécurisé et isolé des données.
Types d’index: Milvus propose une vaste gamme de 15 types d’indexation, notamment HNSW (Hierarchical Navigable Small Worlds) pour des recherches à grande vitesse, PQ (Product Quantization) pour un stockage compact, et DiskANN pour gérer d’immenses ensembles de données. Vous pouvez choisir le type d’indexation qui équilibre le mieux les performances, la précision et le coût, selon votre cas d’utilisation.
Ces technologies font de Milvus un bon choix pour un large éventail d’applications, des déploiements cloud à grande échelle aux appareils en périphérie aux ressources limitées.
Le passage à l’edge computing
À mesure que la demande d’informations en temps réel issues de données non structurées augmente, de nombreuses organisations constatent que s’appuyer uniquement sur des environnements cloud ne suffit pas. Cela a entraîné une transition vers l’edge computing, où le traitement s’effectue plus près de l’endroit où les données sont générées, offrant des avantages distincts pour les applications d’IA sensibles au facteur temps.
L’edge computing désigne la pratique consistant à traiter les données plus près de l’endroit où elles sont générées, souvent sur des appareils en périphérie tels que des capteurs, des caméras et des appareils IoT. Au lieu de renvoyer les données brutes vers des centres de données centralisés pour traitement, l’edge computing permet d’effectuer les calculs sur les appareils eux-mêmes ou dans des emplacements proches.
Avec la disponibilité croissante d’appareils en périphérie puissants, il est devenu possible de déployer des modèles de machine learning et d’IA directement sur ces appareils. Cette approche permet une prise de décision en temps réel dans des applications telles que les véhicules autonomes, les villes intelligentes et l’automatisation industrielle.
Pourquoi traiter les données en périphérie ?
Le traitement des données non structurées en périphérie présente plusieurs avantages :
Faible latence: Comme les données sont traitées près de leur source, le délai d’obtention des résultats est minimal.
Bande passante réduite: En traitant les données localement, vous réduisez la nécessité de transmettre de grands volumes de données brutes vers le cloud.
Confidentialité et sécurité: Les données sensibles peuvent rester sur l’appareil en périphérie, ce qui minimise le risque d’exposition pendant la transmission.
IA en périphérie et bases de données vectorielles
Si l’edge computing rapproche le traitement des données de la source sur des appareils tels que des capteurs, des caméras et de petits appareils comme le Raspberry Pi, c’est la base de données vectorielle qui donne véritablement à ces appareils les moyens de gérer en temps réel le flux croissant de données non structurées.
Par exemple, dans un environnement industriel, des appareils en périphérie surveillent les performances des machines et détectent les problèmes potentiels à l’aide de données de capteurs. Une base de données vectorielle comme Milvus permet à l’appareil en périphérie de comparer rapidement les données entrantes aux modèles historiques, en identifiant les anomalies qui indiquent des besoins de maintenance. Sans la base de données vectorielle, l’appareil en périphérie devrait soit envoyer toutes les données brutes à un serveur cloud pour traitement (ce qui introduirait des retards et des coûts plus élevés), soit risquer de manquer des informations critiques.
Milvus Lite : doter les appareils en périphérie de capacités d’IA
Milvus Lite est la version légère de Milvus, conçue spécifiquement pour les environnements aux ressources limitées tels que les appareils en périphérie. Elle fournit toutes les capacités essentielles d’une base de données vectorielle, mais elle est optimisée pour un déploiement sur du matériel plus petit et moins puissant. Cela en fait une solution idéale pour permettre aux appareils en périphérie de gérer des tâches d’IA complexes, même dans des environnements aux ressources limitées.
Avec Milvus Lite exécuté sur un appareil edge, l’appareil est transformé en processeur de données alimenté par l’IA. Cette combinaison permet à l’appareil edge d’effectuer une reconnaissance d’images localisée, des recherches de similarité vidéo, ou même du traitement du langage naturel. Dans un environnement de vente au détail, par exemple, un système de caisse intelligent alimenté par Milvus Lite pourrait reconnaître instantanément les produits et les comparer à une base de données vectorielle stockée d’articles, accélérant ainsi les transactions sans avoir besoin de systèmes basés sur le cloud.
Voyons un exemple pratique dans lequel Milvus alimente un appareil edge exécuté sur un Raspberry Pi.
Création d’un système d’estimation de pose en temps réel avec Raspberry Pi et Milvus
Raspberry Pi est une série de petits ordinateurs monocartes abordables développés par la Raspberry Pi Foundation. Dans cet exemple, nous utiliserons Raspberry Pi comme appareil edge et Milvus Lite pour gérer les données non structurées.
Ce système d’estimation de pose capturera des flux vidéo, les traitera pour estimer les poses humaines et stockera les vecteurs de caractéristiques extraits dans Milvus pour une récupération efficace par similarité. De plus, nous intégrerons Slack pour les notifications, afin de nous alerter lorsque des poses spécifiques sont détectées.
Vous pouvez consulter le code source de cet exemple dans le notebook de Tim sur GitHub.
Prérequis
Raspberry Pi (avec GStreamer et Python installés)
Configuration de Milvus (soit localement, soit sur un serveur distant)
Compte Slack pour les notifications
Importation des bibliothèques nécessaires et configuration initiale
Commencez par importer les bibliothèques nécessaires et configurer quelques paramètres initiaux :
import gi
gi.require_version('Gst', '1.0')
from gi.repository import Gst, GLib
import os
import argparse
import multiprocessing
import numpy as np
import setproctitle
import cv2
import time
from datetime import datetime
import uuid
import glob
import torch
from torchvision import transforms
from PIL import Image
import timm
from sklearn.preprocessing import normalize
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError
from pymilvus import connections
from pymilvus import utility
from pymilvus import FieldSchema, CollectionSchema, DataType, Collection
from pymilvus import MilvusClient
from pymilvus import MilvusClient
import hailo
from hailo_rpi_common import (
get_default_parser,
QUEUE,
get_caps_from_pad,
get_numpy_from_buffer,
GStreamerApp,
app_callback_class,
)
DIMENSION = 512
MILVUS_URL = "https://in05-7bd87b945683c8d.serverless.gcp-us-west1.cloud.zilliz.com"
COLLECTION_NAME = "rpipose"
TOKEN = os.environ["ZILLIZ_TOKEN"]
PATH = "/opt/demo/images"
time_list = [ 0, 5, 10, 20, 30, 40, 50, 59 ]
Le code ci-dessus importe diverses bibliothèques pour le traitement vidéo (GStreamer), le traitement d’images (OpenCV), l’apprentissage profond (PyTorch, timm), les opérations de base de données (pymilvus) et la communication (SDK Slack). Il importe également la bibliothèque Hailo pour travailler avec l’accélérateur IA, conçu pour permettre les applications d’apprentissage profond sur les appareils edge. Nous configurons des variables globales pour la configuration de la base de données Milvus et définissons une liste d’heures pour les actions périodiques. MILVUSURL et TOKEN nous authentifieront auprès du cloud Zilliz.
Configuration de la base de données Milvus
Ensuite, nous configurons notre connexion à la base de données vectorielle Milvus. Nous utiliserons Milvus pour stocker les caractéristiques extraites du modèle d’estimation de pose.
# Connect to Milvus
# Milvus Lite
# milvus_client = MilvusClient(uri="pipose.db")
# Serveur cloud
milvus_client = MilvusClient( uri=MILVUS_URL, token=TOKEN )
# Créer une collection Milvus qui inclut l’id, le chemin d’accès de l’image et l’embedding de l’image
fields = [
FieldSchema(name='id', dtype=DataType.INT64, is_primary=True, auto_id=True),
FieldSchema(name='label', dtype=DataType.VARCHAR, max_length=200),
FieldSchema(name='lefteye', dtype=DataType.VARCHAR, max_length=200),
FieldSchema(name='righteye', dtype=DataType.VARCHAR, max_length=200),
FieldSchema(name='confidence', dtype=DataType.FLOAT),
FieldSchema(name='vector', dtype=DataType.FLOAT_VECTOR, dim=DIMENSION)
]
schema = CollectionSchema(fields=fields)
milvus_client.create_collection(COLLECTION_NAME, DIMENSION, schema=schema, metric_type="COSINE", auto_id=True)
index_params = milvus_client.prepare_index_params()
index_params.add_index(field_name = "vector", metric_type="COSINE")
milvus_client.create_index(COLLECTION_NAME, index_params)
Ici, nous configurons notre base de données Milvus. Nous créons une connexion client, définissons le schéma de notre collection (y compris des champs pour l’ID, le label, les positions des yeux, la confiance et le vecteur de caractéristiques), créons la collection et configurons un index pour des recherches de similarité efficaces.
Configuration de Slack pour les notifications
Ensuite, configurez une connexion à Slack pour envoyer des notifications :
slack_token = os.environ["SLACK_BOT_TOKEN"]
client = WebClient(token=slack_token)
Cette configuration nous permettra d’envoyer des messages et des fichiers à Slack à l’aide d’un token de bot stocké comme variable d’environnement.
Implémentation de l’extracteur de caractéristiques
Notre système d’estimation de pose nécessite un extracteur de caractéristiques pour convertir les poses détectées dans un format adapté au stockage dans Milvus. Définissons une classe pour cela.
class FeatureExtractor:
def __init__(self, modelname):
# Charger le modèle pré-entraîné
self.model = timm.create_model(
modelname, pretrained=True, num_classes=0, global_pool="avg"
)
self.model.eval()
# Obtenir la taille d’entrée requise par le modèle
self.input_size = self.model.default_cfg["input_size"]
config = resolve_data_config({}, model=modelname)
# Obtenir la fonction de prétraitement fournie par TIMM pour le modèle
self.preprocess = create_transform(**config)
def __call__(self, imagepath):
# Prétraiter l’image d’entrée
input_image = Image.open(imagepath).convert("RGB") # Convertir en RGB si nécessaire
input_image = self.preprocess(input_image)
# Convertir l’image en tenseur PyTorch et ajouter une dimension de lot
input_tensor = input_image.unsqueeze(0)
# Effectuer l’inférence
with torch.no_grad():
output = self.model(input_tensor)
# Extraire le vecteur de caractéristiques
feature_vector = output.squeeze().numpy()
return normalize(feature_vector.reshape(1, -1), norm="l2").flatten()
extractor = FeatureExtractor("resnet34")
Cette classe FeatureExtractor transformera nos images en vecteurs de caractéristiques. Nous utilisons un modèle ResNet34 pré-entraîné pour cette tâche. La méthode __call__ ouvre une image, la prétraite, la fait passer dans le modèle et renvoie un vecteur de caractéristiques normalisé.
Définition d’une classe de rappel utilisateur
Continuez et définissez une classe de rappel utilisateur simple.
class user_app_callback_class(app_callback_class):
def __init__(self):
super().__init__()
Cette classe hérite de app_callback_class et n’ajoute aucune nouvelle fonctionnalité. C’est un espace réservé qui permet une personnalisation future du comportement du rappel.
Création d’une fonction de rappel d’application
La fonction app_callback effectue l’essentiel du traitement. Cette fonction traite les images vidéo, estime les poses et stocke les résultats dans Milvus.
def app_callback(pad, info, user_data):
# Obtenir le GstBuffer depuis les informations de la sonde
lefteye = ""
righteye = ""
buffer = info.get_buffer()
# Vérifier si le buffer est valide
if buffer is None:
return Gst.PadProbeReturn.OK
# Utiliser user_data pour compter le nombre d’images
user_data.increment()
string_to_print = f"Nombre d’images: {user_data.get_count()}\n"
# Obtenir les caps depuis le pad
format, width, height = get_caps_from_pad(pad)
# Si user_data.use_frame est défini sur True, nous pouvons obtenir l’image vidéo depuis le buffer
frame = None
if user_data.use_frame and format is not None and width is not None and height is not None:
# Obtenir l’image vidéo
frame = get_numpy_from_buffer(buffer, format, width, height)
# Obtenir les détections depuis le buffer
roi = hailo.get_roi_from_buffer(buffer)
detections = roi.get_objects_typed(hailo.HAILO_DETECTION)
# Analyser les détections
for detection in detections:
label = detection.get_label()
bbox = detection.get_bbox()
confidence = detection.get_confidence()
if label == "person":
string_to_print += (f"Détection: {label} {confidence:.2f}\n")
# Repères d’estimation de pose depuis la détection (si disponibles)
landmarks = detection.get_objects_typed(hailo.HAILO_LANDMARKS)
if len(landmarks) != 0:
points = landmarks[0].get_points()
left_eye = points[1] # en supposant que 1 est l’indice de l’œil gauche
right_eye = points[2] # en supposant que 2 est l’indice de l’œil droit
# Les repères sont normalisés par rapport à la boîte englobante, nous devons également les convertir à la taille de l’image
left_eye_x = int((left_eye.x() * bbox.width() + bbox.xmin()) * width)
left_eye_y = int((left_eye.y() * bbox.height() + bbox.ymin()) * height)
right_eye_x = int((right_eye.x() * bbox.width() + bbox.xmin()) * width)
right_eye_y = int((right_eye.y() * bbox.height() + bbox.ymin()) * height)
string_to_print += (f" Œil gauche: x: {left_eye_x:.2f} y: {left_eye_y:.2f} Œil droit: x: {right_eye_x:.2f} y: {right_eye_y:.2f}\n")
if user_data.use_frame:
# Ajouter des marqueurs à l’image pour afficher les repères des yeux
cv2.circle(frame, (left_eye_x, left_eye_y), 5, (0, 255, 0), -1)
cv2.circle(frame, (right_eye_x, right_eye_y), 5, (0, 255, 0), -1)
if user_data.use_frame:
# Convertir l’image en BGR
framesave = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
user_data.set_frame(framesave)
time_now = datetime.now()
current_time = int(time_now.strftime("%S"))
if current_time in time_list and len(label) > 4:
# Enregistrer l’image
strfilename = PATH + "/personpose.jpg"
cv2.imwrite(strfilename, framesave)
lefteye = (f"x: {left_eye_x:.2f} y: {left_eye_y:.2f}")
righteye = (f"x: {right_eye_x:.2f} y: {right_eye_y:.2f}")
# Slack
try:
response = client.chat_postMessage(
channel="C06NE1FU6SE",
text=(f"Détection: {label} {confidence:.2f}")
)
except SlackApiError as e:
# Vous obtiendrez une SlackApiError si "ok" est False
assert e.response["error"]
try:
response = client.chat_postMessage(
channel="C06NE1FU6SE",
text=(f" Œil gauche: x: {left_eye_x:.2f} y: {left_eye_y:.2f} Œil droit: x: {right_eye_x:.2f} y: {right_eye_y:.2f}\n")
)
except SlackApiError as e:
# Vous obtiendrez une SlackApiError si "ok" est False
assert e.response["error"]
try:
response = client.files_upload_v2(
channel="C06NE1FU6SE",
file=strfilename,
title=label,
initial_comment="Live Camera image ",
)
except SlackApiError as e:
assert e.response["error"]
# Milvus insert
try:
imageembedding = extractor(strfilename)
milvus_client.insert( COLLECTION_NAME, {"vector": imageembedding, "lefteye": lefteye, "righteye": righteye, "label": label, "confidence": confidence})
except Exception as e:
print("An error:", e)
print(string_to_print)
return Gst.PadProbeReturn.OK
Cette fonction de rappel traite les images vidéo pour détecter les personnes, en se concentrant sur l’extraction de détails comme la boîte englobante, la confiance et les repères des yeux. Elle marque les positions des yeux détectés dans l’image et enregistre l’image de la frame s’il y a une personne dans la frame. De plus, elle envoie des notifications à Slack avec les détails de détection et l’image marquée. La fonction extrait ensuite un vecteur d’embedding à partir de l’image enregistrée. Elle met à jour Milvus avec ces données, notamment l’embedding (vector), les coordonnées des yeux (lefteye et righteye), le libellé de l’objet (label) et la confiance de détection (confidence).
Création de la fonction utilitaire pour les points clés COCO
Créez une fonction utilitaire pour obtenir les points clés COCO. Ce sont des points spécifiques du corps humain qui sont utilisés pour l’estimation de pose.
def get_keypoints():
"""Get the COCO keypoints and their left/right flip correspondence map."""
keypoints = {
'nose': 1,
'left_eye': 2,
'right_eye': 3,
'left_ear': 4,
'right_ear': 5,
'left_shoulder': 6,
'right_shoulder': 7,
'left_elbow': 8,
'right_elbow': 9,
'left_wrist': 10,
'right_wrist': 11,
'left_hip': 12,
'right_hip': 13,
'left_knee': 14,
'right_knee': 15,
'left_ankle': 16,
'right_ankle': 17,
}
return keypoints
Cette fonction renvoie un dictionnaire associant les parties du corps à leurs indices de points clés correspondants au format du jeu de données COCO.
Création du pipeline GStreamer
Poursuivez et créez la classe principale de l’application qui configurera un pipeline GStreamer. Il s’agit d’une séquence d’éléments qui traitent des données multimédias dans un ordre spécifique. Elle traitera des flux vidéo en direct.
# This class inherits from the hailo_rpi_common.GStreamerApp class
class GStreamerPoseEstimationApp(GStreamerApp):
def __init__(self, args, user_data):
# Call the parent class constructor
super().__init__(args, user_data)
# Additional initialization code can be added here
# Set Hailo parameters these parameters should be set based on the model used
self.batch_size = 2
self.network_width = 640
self.network_height = 640
self.network_format = "RGB"
self.default_postprocess_so = os.path.join(self.postprocess_dir, 'libyolov8pose_post.so')
self.post_function_name = "filter"
self.hef_path = os.path.join(self.current_path, '../resources/yolov8s_pose_h8l_pi.hef')
self.app_callback = app_callback
# Set the process title
setproctitle.setproctitle("Hailo Pose Estimation with Milvus")
self.create_pipeline()
def get_pipeline_string(self):
if (self.source_type == "rpi"):
source_element = f"libcamerasrc name=src_0 auto-focus-mode=2 ! "
source_element += f"video/x-raw, format={self.network_format}, width=1536, height=864 ! "
source_element += QUEUE("queue_src_scale")
source_element += f"videoscale ! "
source_element += f"video/x-raw, format={self.network_format}, width={self.network_width}, height={self.network_height}, framerate=30/1 ! "
elif (self.source_type == "usb"):
source_element = f"v4l2src device={self.video_source} name=src_0 ! "
source_element += f"video/x-raw, width=640, height=480, framerate=30/1 ! "
else:
source_element = f"filesrc location={self.video_source} name=src_0 ! "
source_element += QUEUE("queue_dec264")
source_element += f" qtdemux ! h264parse ! avdec_h264 max-threads=2 ! "
source_element += f" video/x-raw,format=I420 ! "
source_element += QUEUE("queue_scale")
source_element += f"videoscale n-threads=2 ! "
source_element += QUEUE("queue_src_convert")
source_element += f"videoconvert n-threads=3 name=src_convert qos=false ! "
source_element += f"video/x-raw, format={self.network_format}, width={self.network_width}, height={self.network_height}, pixel-aspect-ratio=1/1 ! "
pipeline_string = "hailomuxer name=hmux "
pipeline_string += source_element
pipeline_string += "tee name=t ! "
pipeline_string += QUEUE("bypass_queue", max_size_buffers=20) + "hmux.sink_0 "
pipeline_string += "t. ! " + QUEUE("queue_hailonet")
pipeline_string += "videoconvert n-threads=3 ! "
pipeline_string += f"hailonet hef-path={self.hef_path} batch-size={self.batch_size} force-writable=true ! "
pipeline_string += QUEUE("queue_hailofilter")
pipeline_string += f"hailofilter function-name={self.post_function_name} so-path={self.default_postprocess_so} qos=false ! "
pipeline_string += QUEUE("queue_hmuc") + " hmux.sink_1 "
pipeline_string += "hmux. ! " + QUEUE("queue_hailo_python")
pipeline_string += QUEUE("queue_user_callback")
pipeline_string += f"identity name=identity_callback ! "
pipeline_string += QUEUE("queue_hailooverlay")
pipeline_string += f"hailooverlay ! "
pipeline_string += QUEUE("queue_videoconvert")
pipeline_string += f"videoconvert n-threads=3 qos=false ! "
pipeline_string += QUEUE("queue_hailo_display")
pipeline_string += f"fpsdisplaysink video-sink={self.video_sink} name=hailo_display sync={self.sync} text-overlay={self.options_menu.show_fps} signal-fps-measurements=true "
print(pipeline_string)
return pipeline_string
Cette classe configure notre pipeline GStreamer. Elle exécute un modèle d’estimation de pose sur un Raspberry Pi à l’aide d’un accélérateur IA Hailo, qui est un processeur d’IA en périphérie conçu pour exécuter des tâches d’apprentissage profond et d’inférence IA sur des appareils en périphérie. Elle initialise des paramètres comme la taille de lot, les dimensions d’entrée, le format de couleur et les chemins de fichiers pour le modèle de réseau neuronal et le post-traitement. Selon la source d’entrée (par exemple, caméra Raspberry Pi, caméra USB ou fichier vidéo), elle construit un pipeline GStreamer pour capturer la vidéo, la traiter via le modèle Hailo, appliquer le post-traitement et afficher la sortie. La configuration du pipeline est spécifiée dans la méthode get_pipeline_string, qui assemble les éléments GStreamer nécessaires à cette tâche.
Exécution du programme
La dernière étape consiste à exécuter le programme.
if __name__ == "__main__":
# Create an instance of the user app callback class
user_data = user_app_callback_class()
parser = get_default_parser()
args = parser.parse_args()
app = GStreamerPoseEstimationApp(args, user_data)
app.run()
C’est ici que nous connectons tout. Nous créons une instance de notre user_app_callback_class, analysons tous les arguments de ligne de commande, créons notre GStreamerPoseEstimationApp et l’exécutons.
Voici un exemple de résultat auquel vous attendre lorsque vous exécutez le programme.
Fig 2- Sortie d’un programme d’estimation de pose dans Slack avec des repères oculaires marqués par des points verts.png
Fig 2 : Sortie d’un programme d’estimation de pose dans Slack avec des repères oculaires marqués par des points verts
Il s’agit de la mise à jour envoyée à Slack lorsqu’une personne est détectée. Elle comporte un score de confiance de 81 %, les coordonnées des yeux gauche et droit, ainsi que l’image avec les repères oculaires marqués (cercles verts sur les positions des yeux gauche et droit).
Cas d’utilisation de la combinaison de l’IA et des bases de données vectorielles
La combinaison de l’IA en périphérie et des bases de données vectorielles ouvre de nombreux cas d’utilisation. Voici quelques exemples.
Robotique
L’IA en périphérie et les bases de données vectorielles renforcent les capacités des robots autonomes, leur permettant de traiter les données des capteurs localement et de prendre des décisions instantanées. Cette technologie améliore considérablement l’efficacité et l’adaptabilité dans des environnements dynamiques.
Exemple : Dans l’automatisation des entrepôts, les robots mobiles autonomes (AMR) utilisent des caméras embarquées et des bases de données vectorielles locales pour la reconnaissance d’objets en temps réel. Lorsqu’ils se déplacent dans l’entrepôt, ces robots identifient et catégorisent instantanément les produits en comparant les données visuelles à des vecteurs stockés localement. Cela leur permet de s’adapter aux conditions changeantes de l’entrepôt et d’optimiser leurs itinéraires sans dépendre d’une infrastructure cloud.
Villes intelligentes
L’IA en périphérie et les bases de données vectorielles jouent un rôle crucial dans l’optimisation des opérations urbaines, de la gestion du trafic à la sécurité publique. Ces technologies permettent un traitement rapide des données et une prise de décision en périphérie, améliorant l’efficacité des villes et la qualité de vie des habitants.
Exemple : Les systèmes intelligents de gestion du trafic exploitent l’IA en périphérie pour traiter localement les flux vidéo provenant des caméras d’intersection. Le système convertit les schémas de circulation en représentations vectorielles et les compare aux données historiques stockées dans une base de données vectorielle locale. Cela permet des ajustements en temps réel des feux de circulation afin de réduire les embouteillages, garantissant des temps de réponse rapides sans nécessiter une transmission constante des données vers des serveurs centraux.
Automatisation industrielle
L’IA en périphérie et les bases de données vectorielles favorisent la maintenance prédictive et la surveillance des équipements dans les environnements manufacturiers et industriels. Cette approche permet une analyse en temps réel de l’état des machines, évitant les temps d’arrêt et optimisant les processus de production.
Exemple : Les usines intelligentes déploient des capteurs sur les machines critiques afin de collecter en continu des données de vibration. Les dispositifs en périphérie convertissent ces données en représentations vectorielles et les comparent à des modèles de vibration connus comme « sains » et « défectueux » stockés dans une base de données vectorielle locale. Cette analyse en temps réel permet la détection immédiate de potentielles défaillances d’équipement, facilitant une maintenance proactive et minimisant les interruptions coûteuses.
Santé
L’IA en périphérie et les bases de données vectorielles transforment les soins aux patients en permettant une surveillance continue de la santé sans compromettre la confidentialité. Ces technologies permettent une analyse sophistiquée des données de santé directement sur des dispositifs portables ou des systèmes locaux.
Exemple : Les moniteurs ECG portables utilisent l’IA en périphérie pour traiter localement les données du rythme cardiaque. Le dispositif convertit les schémas ECG en vecteurs et les compare à une base de données de rythmes normaux et anormaux stockée à bord. Cette approche permet la détection immédiate de problèmes cardiaques potentiels tout en conservant les données de santé sensibles sur le dispositif, améliorant à la fois la réactivité et la confidentialité des patients.
Conclusion
À mesure que les données non structurées gagnent en volume et en importance, des solutions de traitement efficaces deviennent de plus en plus cruciales. Tim a bien mis en évidence le potentiel transformateur des bases de données vectorielles comme Milvus, qui offrent des capacités avancées pour les déploiements dans le cloud comme en périphérie. Que ce soit pour des applications d’IA à grande échelle ou pour des appareils en périphérie aux ressources limitées, Milvus et son équivalent léger, Milvus Lite, permettent aux organisations d’exploiter les données non structurées pour la prise de décision en temps réel, l’innovation et l’efficacité opérationnelle. Grâce à la flexibilité permettant de passer du cloud à la périphérie, ces technologies sont à l’avant-garde des solutions modernes pilotées par l’IA.
Ressources supplémentaires
Les projets d’IA de Tim sur GitHub :
Traitement des données non structurées avec un kit d’IA Raspberry Pi
Modèles d’IA les plus performants pour vos applications GenAI | Zilliz
Continuer à lire
How to Choose the Best Embedding Model for RAG in 2026: 10 Models Benchmarked
We benchmarked 10 embedding models on cross-modal, cross-lingual, long-document, and dimension compression tasks. See which one fits your RAG pipeline.
Zilliz Cloud Now Available in Azure North Europe: Bringing AI-Powered Vector Search Closer to European Customers
The addition of the Azure North Europe (Ireland) region further expands our global footprint to better serve our European customers.
Milvus/Zilliz + Surveillance: How Vector Databases Transform Multi-Camera Tracking
See how Milvus vector database enhances multi-camera tracking with similarity-based matching for better surveillance in retail, warehouses and transport hubs.