Elaborazione dei dati non strutturati dal cloud all'edge
I dati non strutturati rappresentano ormai circa l'80% dei dati che gestiamo, spaziando da testo e immagini a video, audio e formati più complessi. Con l'aumento del loro volume, cresce anche la necessità di modi migliori per elaborarli e analizzarli.
In un recente webinar, Tim Spann, Principal Developer Advocate presso Zilliz, ha condiviso le sue intuizioni sulla gestione dei dati non strutturati, in particolare dagli ambienti cloud ai dispositivi edge. Ha inoltre evidenziato come i database vettoriali come Milvus siano fondamentali per dare senso a questi dati.
In questo post, ricapitoleremo i punti principali di Tim, discutendo le sfide nella gestione dei dati non strutturati e il modo in cui i database vettoriali stanno aprendo la strada. Esamineremo anche come i dispositivi edge alimentati da questi database stiano guidando nuovi progressi nell'IA. Se ti interessano maggiori dettagli, consigliamo di guardare la registrazione completa dell'intervento di Tim su YouTube.
Comprendere i dati non strutturati
I dati non strutturati si riferiscono a informazioni prive di un formato o di uno schema predefinito. A differenza dei dati strutturati, che sono ordinatamente organizzati in database con campi e formati specifici, i dati non strutturati sono grezzi e non organizzati. Spesso includono:
Testo: Email, documenti Word, post sui social media
Immagini: Foto, screenshot, diagrammi
Video: Riunioni registrate, filmati di sorveglianza, contenuti multimediali
Audio: Registrazioni vocali, file musicali, podcast
Con l'impennata dei contenuti digitali, i dati non strutturati sono cresciuti in modo esponenziale, offrendo alle organizzazioni sia opportunità sia sfide. Per capitalizzare su questa ricchezza di informazioni, le aziende possono:
Migliorare l'esperienza del cliente analizzando le interazioni e il feedback dei clienti
Migliorare l'efficienza operativa tramite insight ricavati dai dati dei sensori e dai log di sistema
Promuovere l'innovazione sfruttando i contenuti multimediali per lo sviluppo del prodotto
I database tradizionali, progettati per gestire dati strutturati, faticano con l'irregolarità dei dati non strutturati, rendendo difficile cercare, interrogare o estrarre insight significativi. È qui che i database vettoriali diventano essenziali, offrendo una soluzione per gestire e recuperare informazioni non strutturate in modo efficiente.
Perché utilizzare un database vettoriale per l'elaborazione dei dati non strutturati?
Un database vettoriale è un database specializzato progettato per archiviare, indicizzare e interrogare rappresentazioni vettoriali dei dati (note anche come embedding vettoriali), spesso derivate da dati non strutturati come testo, immagini e audio. Questi database consentono efficienti ricerche di similarità in uno spazio ad alta dimensionalità, rendendoli ideali per la ricerca semantica, l'elaborazione del linguaggio naturale (NLP), i sistemi di raccomandazione, le ricerche di immagini e la retrieval augmented generation (RAG).
I database vettoriali come Milvus e Zilliz Cloud offrono una gamma di funzionalità oltre alle capacità di ricerca ad alte prestazioni, che li rendono cruciali per la gestione dei dati non strutturati.
Oltre la ricerca ad alte prestazioni
Sebbene i database vettoriali siano spesso associati a capacità di ricerca di similarità rapide, la loro utilità va molto oltre. Forniscono altre funzioni essenziali che garantiscono la gestione e l’utilizzo efficaci dei dati non strutturati:
Operazioni CRUD: I database vettoriali, come i database tradizionali, consentono di creare, leggere, aggiornare ed eliminare (CRUD) i dati. Questo garantisce che, nonostante si lavori con tipi di dati complessi, le operazioni di base rimangano intuitive e accessibili.
Freschezza dei dati: Uno dei principali punti di forza dei database vettoriali è garantire che i dati rimangano aggiornati. In casi d’uso come i sistemi di raccomandazione, mantenere i dati aggiornati è essenziale per generare insight accurati.
Persistenza: A differenza delle strutture dati in memoria, i database vettoriali offrono archiviazione persistente, il che significa che i dati vengono archiviati in modo sicuro e rimangono accessibili anche dopo i riavvii del sistema.
Disponibilità: I database vettoriali mantengono i dati prontamente accessibili per query e recupero in tempo reale. Questo garantisce che, anche con la crescita dei dati, sia comunque possibile eseguire ricerche rapide ed efficienti, consentendo decisioni guidate dall’AI senza ritardi.
Scalabilità: Con l’aumentare del volume dei dati, i database vettoriali scalano in modo efficiente per accogliere tale crescita senza degrado delle prestazioni. Questo è essenziale quando si gestiscono miliardi di punti dati non strutturati.
Gestione completa dei dati
Oltre alle funzioni sopra indicate, i database vettoriali forniscono strumenti robusti per gestire i dati non strutturati, tra cui ingestione dei dati, indicizzazione e query, consentendo il recupero e l’analisi efficienti anche dei dataset più grandi. Funzionalità come backup e migrazione garantiscono che i dati rimangano sicuri e recuperabili, rendendo i database vettoriali una scelta affidabile per la gestione di informazioni critiche.
Semplicità operativa
I database vettoriali sono inoltre progettati per semplificare la distribuzione e la gestione:
Distribuzione cloud o on-premise: Molti database vettoriali purpose-built sono versatili e possono essere facilmente distribuiti su cloud pubblici o su infrastruttura on-premise, garantendo flessibilità in base alle esigenze dell’organizzazione.
Osservabilità: Molti database vettoriali offrono strumenti di monitoraggio per tracciare lo stato di salute e le prestazioni del database, consentendo agli utenti di ottimizzare i propri sistemi in modo proattivo.
Multi-tenancy: I database vettoriali come Zilliz Cloud supportano più utenti o applicazioni, garantendo accesso sicuro e gestione isolata dei dati per ciascun tenant. Questo li rende ideali per distribuzioni su larga scala in cui più team necessitano di ambienti dati isolati.
Il ruolo di Milvus nella gestione dei dati non strutturati
Milvus è un database vettoriale open-source progettato per archiviare, indicizzare e recuperare in modo efficiente vettori ad alta dimensionalità su scala di miliardi, rendendolo ideale per casi d’uso che coinvolgono AI e machine learning, come sistemi di raccomandazione, riconoscimento delle immagini o retrieval-augmented generation (RAG).
Milvus offre molteplici opzioni di distribuzione per soddisfare esigenze diversificate dei clienti.
Milvus open-source: Open-source, autogestito e può essere ospitato su qualsiasi macchina con supporto della community. Milvus offre inoltre molteplici opzioni di distribuzione per varie esigenze e ambienti, tra cui Milvus Lite, Milvus Standalone e Milvus Distributed. Consulta la documentazione di Milvus per maggiori dettagli.
Zilliz Cloud: versione completamente gestita di Milvus, riprogettata per il cloud e disponibile sui principali cloud pubblici come AWS, GCP e Azure.
Zilliz BYOC: Milvus pronto per l'enterprise per VPC privati e può essere distribuito nel tuo cloud privato virtuale.
Fig 1- Ways of deploying Milvus .png
Fig 1: Modi per distribuire Milvus
Funzionalità chiave di Milvus
Milvus è progettato per alte prestazioni e scalabilità, offrendo funzionalità come:
Figure- Milvus key features .png
Figura: funzionalità chiave di Milvus
Multi-tenancy: Milvus consente a più utenti o applicazioni di lavorare sullo stesso sistema senza interferire tra loro, fornendo accesso sicuro a dati isolati.
Hardware-accelerated Compute: ottimizzato per sfruttare hardware come le GPU, rendendolo più veloce ed efficiente per attività ad alta intensità di risorse come l'inferenza di modelli AI.
Language and API Support: Milvus è estremamente versatile e supporta Python, Java, Golang, NodeJS, ecc., rendendolo accessibile a un'ampia gamma di sviluppatori.
Scalable and Elastic Architecture: Milvus è progettato per gestire esigenze di dati in crescita. Si ridimensiona automaticamente per soddisfare la domanda, garantendo che le prestazioni rimangano ottimali man mano che i dati crescono.
Diverse Index Support: supporta più tipi di indici, inclusi HNSW, PQ, Binary e DiskANN, offrendo flessibilità nel modo in cui i dati vengono archiviati e ricercati.
Tunable Consistency: Milvus consente di regolare i livelli di consistenza per i dati, permettendoti di bilanciare prestazioni e accuratezza dei dati in base alle esigenze dell'applicazione.
Per informazioni più dettagliate, consulta la documentazione di Milvus.
Tecnologie alla base di Milvus per vari casi d'uso
Milvus è supportato da una suite di tecnologie che soddisfano diversi tipi di applicazioni, garantendo prestazioni, flessibilità e scalabilità in vari ambienti:
Figure- Milvus technologies for various use cases .png
Figura: tecnologie di Milvus per vari casi d'uso
Compute Types: Milvus è ottimizzato per diversi ambienti hardware, inclusi AVX512 (un set di istruzioni CPU per il calcolo ad alta velocità), Neon per SIMD (Single Instruction, Multiple Data) e accelerazione GPU. Ciò garantisce che Milvus possa utilizzare hardware ad alte prestazioni per offrire elaborazione rapida e scalabilità conveniente.
Search Types: Milvus supporta un'ampia gamma di metodi di ricerca, come top-K ANN (Approximate Nearest Neighbors) per trovare i punti dati più simili, range ANN, ricerche sparse e dense e ricerche filtrate. Questi ci consentono di adattare la funzionalità di ricerca alle esigenze specifiche delle nostre applicazioni, che si tratti di identificare immagini, video o testo simili.
Multi-tenancy: Milvus supporta la gestione di collezioni e partizioni, abilitando la multi-tenancy. Questa funzionalità consente a team o applicazioni diversi di condividere lo stesso database senza interferire con i dati reciproci, garantendo una gestione dei dati sicura e isolata.
Tipi di indice: Milvus offre un'ampia gamma di 15 tipi di indicizzazione, tra cui HNSW (Hierarchical Navigable Small Worlds) per ricerche ad alta velocità, PQ (Product Quantization) per l'archiviazione compatta e DiskANN per gestire dataset massivi. Puoi scegliere il tipo di indicizzazione che bilancia al meglio prestazioni, accuratezza e costi, a seconda del tuo caso d'uso.
Queste tecnologie rendono Milvus una buona scelta per un'ampia gamma di applicazioni, dalle distribuzioni cloud su larga scala ai dispositivi edge con risorse limitate.
Il passaggio all'Edge Computing
Con la crescita della domanda di insight in tempo reale da dati non strutturati, molte organizzazioni scoprono che affidarsi esclusivamente agli ambienti cloud non è sufficiente. Questo ha portato a un passaggio verso l'edge computing, in cui l'elaborazione avviene più vicino al luogo in cui i dati vengono generati, offrendo vantaggi distinti per le applicazioni di IA sensibili al fattore tempo.
Edge computing si riferisce alla pratica di elaborare i dati più vicino al luogo in cui vengono generati, spesso su dispositivi edge come sensori, telecamere e dispositivi IoT. Invece di inviare i dati grezzi ai data center centralizzati per l'elaborazione, l'edge computing consente di eseguire i calcoli sui dispositivi stessi o in luoghi vicini.
Con la crescente disponibilità di potenti dispositivi edge, è diventato possibile distribuire modelli di machine learning e IA direttamente su questi dispositivi. Questo approccio consente di prendere decisioni in tempo reale in applicazioni come veicoli autonomi, smart city e automazione industriale.
Perché elaborare i dati all'edge?
L'elaborazione dei dati non strutturati all'edge presenta diversi vantaggi:
Bassa latenza: Poiché i dati vengono elaborati vicino alla loro origine, il ritardo nell'ottenere i risultati è minimo.
Larghezza di banda ridotta: Elaborando i dati localmente, riduci la necessità di trasmettere grandi volumi di dati grezzi al cloud.
Privacy e sicurezza: I dati sensibili possono rimanere sul dispositivo edge, minimizzando il rischio di esposizione durante la trasmissione.
Edge AI e database vettoriali
Sebbene l'edge computing avvicini l'elaborazione dei dati alla fonte su dispositivi come sensori, telecamere e piccoli dispositivi come Raspberry Pi, è il database vettoriale che permette davvero a questi dispositivi di gestire in tempo reale il crescente flusso di dati non strutturati.
Ad esempio, in un contesto industriale, i dispositivi edge monitorano le prestazioni dei macchinari e rilevano potenziali problemi utilizzando i dati dei sensori. Un database vettoriale come Milvus consente al dispositivo edge di confrontare rapidamente i dati in ingresso con i pattern storici, identificando anomalie che indicano esigenze di manutenzione. Senza il database vettoriale, il dispositivo edge dovrebbe inviare tutti i dati grezzi a un server cloud per l'elaborazione (introducendo ritardi e costi più elevati) oppure rischierebbe di perdere insight critici.
Milvus Lite: potenziare i dispositivi edge con capacità di IA
Milvus Lite è la versione leggera di Milvus, progettata specificamente per ambienti con risorse limitate come i dispositivi edge. Offre tutte le capacità essenziali di un database vettoriale, ma è ottimizzata per la distribuzione su hardware più piccolo e meno potente. Questo la rende una soluzione ideale per consentire ai dispositivi edge di gestire attività di IA complesse, anche in ambienti con risorse limitate.
Con Milvus Lite in esecuzione su un dispositivo edge, il dispositivo viene trasformato in un elaboratore di dati basato sull’IA. Questa combinazione consente al dispositivo edge di eseguire riconoscimento delle immagini localizzato, ricerche di similarità video o persino elaborazione del linguaggio naturale. In un contesto retail, ad esempio, un sistema di checkout intelligente basato su Milvus Lite potrebbe riconoscere istantaneamente i prodotti e confrontarli con un database vettoriale archiviato di articoli, accelerando le transazioni senza la necessità di sistemi basati sul cloud.
Vediamo un esempio pratico in cui Milvus alimenta un dispositivo edge in esecuzione su un Raspberry Pi.
Creazione di un sistema di stima della posa in tempo reale con Raspberry Pi e Milvus
Raspberry Pi è una serie di computer a scheda singola piccoli, economici, sviluppati dalla Raspberry Pi Foundation. In questo esempio, useremo Raspberry Pi come dispositivo edge e Milvus Lite per gestire dati non strutturati.
Questo sistema di stima della posa catturerà flussi video, li elaborerà per stimare le pose umane e archivierà i vettori di caratteristiche estratti in Milvus per un recupero efficiente per similarità. Inoltre, integreremo Slack per le notifiche, avvisandoci quando vengono rilevate pose specifiche.
Puoi consultare il codice sorgente di questo esempio nel notebook di Tim su GitHub.
Prerequisiti
Raspberry Pi (con GStreamer e Python installati)
Account Slack per le notifiche
Importazione delle librerie necessarie e configurazione iniziale
Inizia importando le librerie necessarie e impostando alcune configurazioni iniziali:
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 ]
Il codice sopra importa varie librerie per l’elaborazione video (GStreamer), l’elaborazione delle immagini (OpenCV), il deep learning (PyTorch, timm), le operazioni di database (pymilvus) e la comunicazione (Slack SDK). Importa inoltre la libreria Hailo per lavorare con l’acceleratore IA, progettata per abilitare applicazioni di deep learning su dispositivi edge. Impostiamo variabili globali per la configurazione del database Milvus e definiamo un elenco di tempi per azioni periodiche. MILVUSURL E TOKEN ci autenticheranno con il cloud Zilliz.
Configurazione del database Milvus
Successivamente, configuriamo la nostra connessione al database vettoriale Milvus. Useremo Milvus per archiviare le caratteristiche estratte dal modello di stima della posa.
# Connect to Milvus
# Milvus Lite
# milvus_client = MilvusClient(uri="pipose.db")
# Cloud Server
milvus_client = MilvusClient( uri=MILVUS_URL, token=TOKEN )
# Create Milvus collection which includes the id, filepath of the image, and image embedding
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)
Qui stiamo configurando il nostro database Milvus. Creiamo una connessione client, definiamo lo schema per la nostra collection (includendo campi per ID, etichetta, posizioni degli occhi, confidenza e il vettore di feature), creiamo la collection e configuriamo un indice per ricerche di similarità efficienti.
Configurazione di Slack per le notifiche
Successivamente, configura una connessione a Slack per inviare notifiche:
slack_token = os.environ["SLACK_BOT_TOKEN"]
client = WebClient(token=slack_token)
Questa configurazione ci permetterà di inviare messaggi e file a Slack usando un token bot memorizzato come variabile d’ambiente.
Implementazione dell’estrattore di feature
Il nostro sistema di stima della posa richiede un estrattore di feature per convertire le pose rilevate in un formato adatto all’archiviazione in Milvus. Definiamo una classe per questo.
class FeatureExtractor:
def __init__(self, modelname):
# Load the pre-trained model
self.model = timm.create_model(
modelname, pretrained=True, num_classes=0, global_pool="avg"
)
self.model.eval()
# Get the input size required by the model
self.input_size = self.model.default_cfg["input_size"]
config = resolve_data_config({}, model=modelname)
# Get the preprocessing function provided by TIMM for the model
self.preprocess = create_transform(**config)
def __call__(self, imagepath):
# Preprocess the input image
input_image = Image.open(imagepath).convert("RGB") # Convert to RGB if needed
input_image = self.preprocess(input_image)
# Convert the image to a PyTorch tensor and add a batch dimension
input_tensor = input_image.unsqueeze(0)
# Perform inference
with torch.no_grad():
output = self.model(input_tensor)
# Extract the feature vector
feature_vector = output.squeeze().numpy()
return normalize(feature_vector.reshape(1, -1), norm="l2").flatten()
extractor = FeatureExtractor("resnet34")
Questa classe FeatureExtractor trasformerà le nostre immagini in vettori di feature. Stiamo usando un modello ResNet34 pre-addestrato per questo compito. Il metodo __call__ apre un’immagine, la pre-elabora, la esegue attraverso il modello e restituisce un vettore di feature normalizzato.
Definizione di una classe di callback utente
Continua e definisci una semplice classe di callback utente.
class user_app_callback_class(app_callback_class):
def __init__(self):
super().__init__()
Questa classe eredita da app_callback_class e non aggiunge alcuna nuova funzionalità. È un segnaposto che consente una futura personalizzazione del comportamento della callback.
Creazione di una funzione di callback dell’applicazione
La funzione app_callback esegue la maggior parte dell’elaborazione. Questa funzione elabora i frame video, stima le pose e archivia i risultati in Milvus.
def app_callback(pad, info, user_data):
# Get the GstBuffer from the probe info
lefteye = ""
righteye = ""
buffer = info.get_buffer()
# Controlla se il buffer è valido
if buffer is None:
return Gst.PadProbeReturn.OK
# Uso di user_data per contare il numero di frame
user_data.increment()
string_to_print = f"Conteggio frame: {user_data.get_count()}\n"
# Ottieni i caps dal pad
format, width, height = get_caps_from_pad(pad)
# Se user_data.use_frame è impostato su True, possiamo ottenere il frame video dal buffer
frame = None
if user_data.use_frame and format is not None and width is not None and height is not None:
# Ottieni il frame video
frame = get_numpy_from_buffer(buffer, format, width, height)
# Ottieni i rilevamenti dal buffer
roi = hailo.get_roi_from_buffer(buffer)
detections = roi.get_objects_typed(hailo.HAILO_DETECTION)
# Analizza i rilevamenti
for detection in detections:
label = detection.get_label()
bbox = detection.get_bbox()
confidence = detection.get_confidence()
if label == "person":
string_to_print += (f"Rilevamento: {label} {confidence:.2f}\n")
# Landmark di stima della posa dal rilevamento (se disponibili)
landmarks = detection.get_objects_typed(hailo.HAILO_LANDMARKS)
if len(landmarks) != 0:
points = landmarks[0].get_points()
left_eye = points[1] # supponendo che 1 sia l'indice per l'occhio sinistro
right_eye = points[2] # supponendo che 2 sia l'indice per l'occhio destro
# I landmark sono normalizzati rispetto al riquadro di delimitazione, dobbiamo anche convertirli alla dimensione del frame
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" Occhio sinistro: x: {left_eye_x:.2f} y: {left_eye_y:.2f} Occhio destro: x: {right_eye_x:.2f} y: {right_eye_y:.2f}\n")
if user_data.use_frame:
# Aggiungi marcatori al frame per mostrare i landmark degli occhi
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:
# Converti il frame in 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:
# Salva immagine
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"Rilevamento: {label} {confidence:.2f}")
)
except SlackApiError as e:
# Riceverai uno SlackApiError se "ok" è False
assert e.response["error"]
try:
response = client.chat_postMessage(
channel="C06NE1FU6SE",
text=(f" Occhio sinistro: x: {left_eye_x:.2f} y: {left_eye_y:.2f} Occhio destro: x: {right_eye_x:.2f} y: {right_eye_y:.2f}\n")
)
except SlackApiError as e:
# Riceverai uno SlackApiError se "ok" è 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
Questa funzione di callback elabora i frame video per rilevare persone, concentrandosi sull'estrazione di dettagli come il riquadro di delimitazione, la confidenza e i landmark degli occhi. Contrassegna le posizioni degli occhi rilevate nel frame e salva l'immagine del frame se c'è una persona nel frame. Inoltre, invia notifiche a Slack con i dettagli del rilevamento e l'immagine contrassegnata. La funzione quindi estrae un vettore di embedding dall'immagine salvata. Aggiorna Milvus con questi dati, inclusi l'embedding (vector), le coordinate degli occhi (lefteye e righteye), l'etichetta dell'oggetto (label) e la confidenza del rilevamento (confidence).
Creazione della funzione di utilità per i keypoint COCO
Crea una funzione di utilità per ottenere i keypoint COCO. Si tratta di punti specifici sul corpo umano utilizzati per la stima della posa.
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
Questa funzione restituisce un dizionario che mappa le parti del corpo ai rispettivi indici dei keypoint nel formato del dataset COCO.
Creazione della pipeline GStreamer
Procedi e crea la classe principale dell'applicazione che configurerà una pipeline GStreamer. Questa è una sequenza di elementi che elaborano dati multimediali in un ordine specifico. Elaborerà flussi video live.
# 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
Questa classe configura la nostra pipeline GStreamer. Esegue un modello di stima della posa su un Raspberry Pi utilizzando un acceleratore AI Hailo, che è un processore AI edge progettato per eseguire attività di deep learning e inferenza AI su dispositivi edge. Inizializza parametri come dimensione del batch, dimensioni di input, formato colore e percorsi dei file per il modello di rete neurale e la post-elaborazione. A seconda della sorgente di input (ad esempio, fotocamera Raspberry Pi, fotocamera USB o file video), costruisce una pipeline GStreamer per acquisire il video, elaborarlo tramite il modello Hailo, applicare la post-elaborazione e visualizzare l'output. La configurazione della pipeline è specificata nel metodo get_pipeline_string, che assembla gli elementi GStreamer necessari per questa attività.
Esecuzione del Programma
Il passaggio finale è eseguire il programma.
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()
È qui che colleghiamo tutto. Creiamo un'istanza della nostra user_app_callback_class, analizziamo eventuali argomenti della riga di comando, creiamo la nostra GStreamerPoseEstimationApp e la eseguiamo.
Ecco un esempio di risultato di cosa aspettarsi quando si esegue il programma.
Fig 2- Output of a pose estimation program in Slack with eye landmarks marked with green dots.png
Fig 2: Output di un programma di stima della posa in Slack con punti di riferimento degli occhi contrassegnati da punti verdi
Questo è l'aggiornamento a Slack quando viene rilevata una persona. Ha un punteggio di confidenza dell'81%, le coordinate degli occhi sinistro e destro e l'immagine con i punti di riferimento degli occhi contrassegnati (cerchi verdi sulle posizioni degli occhi sinistro e destro).
Casi d'uso della combinazione di IA e database vettoriali
La combinazione di IA edge e database vettoriali dà origine a numerosi casi d'uso. Di seguito sono riportati alcuni esempi.
Robotica
L'IA edge e i database vettoriali migliorano le capacità dei robot autonomi, consentendo loro di elaborare i dati dei sensori localmente e prendere decisioni istantanee. Questa tecnologia migliora significativamente l'efficienza e l'adattabilità in ambienti dinamici.
Esempio: nell'automazione dei magazzini, i robot mobili autonomi (AMR) utilizzano telecamere integrate e database vettoriali locali per il riconoscimento degli oggetti in tempo reale. Mentre navigano nel magazzino, questi robot identificano e categorizzano istantaneamente i prodotti confrontando i dati visivi con vettori archiviati localmente. Ciò consente loro di adattarsi alle condizioni mutevoli del magazzino e ottimizzare i loro percorsi senza fare affidamento sull'infrastruttura cloud.
Città intelligenti
L'IA edge e i database vettoriali svolgono un ruolo cruciale nell'ottimizzazione delle operazioni urbane, dalla gestione del traffico alla sicurezza pubblica. Queste tecnologie consentono l'elaborazione rapida dei dati e il processo decisionale all'edge, migliorando l'efficienza della città e la qualità della vita dei residenti.
Esempio: i sistemi intelligenti di gestione del traffico sfruttano l'IA edge per elaborare localmente i feed video dalle telecamere agli incroci. Il sistema converte i modelli di traffico in rappresentazioni vettoriali e li confronta con i dati storici archiviati in un database vettoriale locale. Ciò consente regolazioni in tempo reale dei semafori per ridurre la congestione, garantendo tempi di risposta rapidi senza la necessità di una trasmissione costante dei dati ai server centrali.
Automazione industriale
L'IA edge e i database vettoriali favoriscono la manutenzione predittiva e il monitoraggio delle apparecchiature negli ambienti produttivi e industriali. Questo approccio consente l'analisi in tempo reale dello stato di salute delle macchine, prevenendo i tempi di inattività e ottimizzando i processi di produzione.
Esempio: gli impianti di produzione intelligenti installano sensori su macchinari critici per raccogliere continuamente dati sulle vibrazioni. I dispositivi edge convertono questi dati in rappresentazioni vettoriali e li confrontano con modelli di vibrazione noti come "sani" e "difettosi" archiviati in un database vettoriale locale. Questa analisi in tempo reale consente il rilevamento immediato di potenziali guasti delle apparecchiature, facilitando la manutenzione proattiva e riducendo al minimo costose interruzioni.
Sanità
L'IA edge e i database vettoriali trasformano l'assistenza ai pazienti consentendo il monitoraggio continuo della salute senza compromettere la privacy. Queste tecnologie permettono un'analisi sofisticata dei dati sanitari direttamente su dispositivi indossabili o sistemi locali.
Esempio: i monitor ECG indossabili utilizzano l'IA edge per elaborare localmente i dati del ritmo cardiaco. Il dispositivo converte i tracciati ECG in vettori e li confronta con un database di ritmi normali e anomali archiviato a bordo. Questo approccio consente il rilevamento immediato di potenziali problemi cardiaci mantenendo i dati sanitari sensibili sul dispositivo, migliorando sia la reattività sia la privacy del paziente.
Conclusione
Con la crescita in scala e importanza dei dati non strutturati, soluzioni di elaborazione efficienti diventano sempre più cruciali. Tim ha svolto un ottimo lavoro nel mettere in evidenza il potenziale trasformativo dei database vettoriali come Milvus, offrendo capacità avanzate sia per implementazioni cloud sia edge. Che si tratti di applicazioni AI su larga scala o di dispositivi edge con risorse limitate, Milvus e la sua controparte leggera, Milvus Lite, consentono alle organizzazioni di sfruttare i dati non strutturati per il processo decisionale in tempo reale, l’innovazione e l’efficienza operativa. Con la flessibilità di scalare dal cloud all’edge, queste tecnologie sono all’avanguardia delle moderne soluzioni guidate dall’AI.
Ulteriori risorse
I progetti AI di Tim su GitHub:
Elaborazione di dati non strutturati con un kit AI Raspberry Pi
Modelli AI con le migliori prestazioni per le tue app GenAI | Zilliz
Continua a leggere
Why Not All VectorDBs Are Agent-Ready
Explore why choosing the right vector database is critical for scaling AI agents, and why traditional solutions fall short in production.
Cosmos World Foundation Model Platform for Physical AI
NVIDIA's Cosmos platform enables safe, digital twin training of GenAI models for physical applications, overcoming data scarcity and safety challenges.
VidTok: Rethinking Video Processing with Compact Tokenization
VidTok tokenizes videos to reduce redundancy while preserving spatial and temporal details for efficient processing.