Обработка неструктурированных данных от облака до периферии
Неструктурированные данные теперь составляют около 80% данных, с которыми мы работаем, от текста и изображений до видео, аудио и более сложных форматов. По мере роста их объема растет и потребность в более эффективных способах их обработки и анализа.
На недавнем вебинаре Tim Spann, Principal Developer Advocate в Zilliz, поделился своими взглядами на управление неструктурированными данными, особенно от облачных сред до периферийных устройств. Он также подчеркнул, что векторные базы данных, такие как Milvus, играют ключевую роль в осмыслении этих данных.
В этой статье мы кратко изложим основные тезисы Тима, обсудим проблемы обработки неструктурированных данных и то, как векторные базы данных становятся ведущим решением. Мы также рассмотрим, как периферийные устройства на базе этих баз данных способствуют новым достижениям в области ИИ. Если вам интересны дополнительные подробности, рекомендуем посмотреть полную запись выступления Tim на YouTube.
Понимание неструктурированных данных
Неструктурированные данные — это информация, у которой отсутствует заранее заданный формат или схема. В отличие от структурированных данных, которые аккуратно организованы в базах данных с определенными полями и форматами, неструктурированные данные являются сырыми и неорганизованными. Они часто включают:
Текст: электронные письма, документы Word, публикации в социальных сетях
Изображения: фотографии, скриншоты, диаграммы
Видео: записи встреч, кадры видеонаблюдения, мультимедийный контент
Аудио: голосовые записи, музыкальные файлы, подкасты
С резким ростом цифрового контента объем неструктурированных данных увеличился экспоненциально, предоставляя организациям как возможности, так и вызовы. Чтобы извлечь пользу из этого богатства информации, компании могут:
Улучшить клиентский опыт за счет анализа взаимодействий с клиентами и обратной связи
Повысить операционную эффективность благодаря инсайтам из данных датчиков и системных журналов
Стимулировать инновации за счет использования мультимедийного контента для разработки продуктов
Традиционные базы данных, предназначенные для работы со структурированными данными, с трудом справляются с нерегулярностью неструктурированных данных, что затрудняет поиск, запросы или извлечение значимых инсайтов. Именно здесь векторные базы данных становятся необходимыми, предлагая решение для эффективного управления неструктурированной информацией и ее извлечения.
Зачем использовать векторную базу данных для обработки неструктурированных данных?
Векторная база данных — это специализированная база данных, предназначенная для хранения, индексации и выполнения запросов к векторным представлениям данных (также известным как векторные эмбеддинги), часто полученным из неструктурированных данных, таких как текст, изображения и аудио. Эти базы данных обеспечивают эффективный поиск по сходству в многомерном пространстве, что делает их идеальными для семантического поиска, обработки естественного языка (NLP), рекомендательных систем, поиска изображений и генерации с расширенным извлечением (RAG).
Векторные базы данных, такие как Milvus и Zilliz Cloud, предлагают ряд функциональных возможностей помимо высокопроизводительного поиска, которые делают их критически важными для управления неструктурированными данными.
За пределами высокопроизводительного поиска
Хотя векторные базы данных часто ассоциируются с возможностями быстрого поиска по сходству, их полезность простирается гораздо дальше. Они предоставляют другие важные функции, которые обеспечивают эффективное управление неструктурированными данными и их использование:
CRUD-операции: Векторные базы данных, как и традиционные базы данных, позволяют создавать, читать, обновлять и удалять (CRUD) данные. Это гарантирует, что, несмотря на работу со сложными типами данных, базовые операции остаются интуитивно понятными и доступными.
Актуальность данных: Одной из ключевых сильных сторон векторных баз данных является обеспечение актуальности ваших данных. В сценариях использования, таких как рекомендательные системы, поддержание данных в актуальном состоянии необходимо для получения точных аналитических выводов.
Персистентность: В отличие от структур данных в оперативной памяти, векторные базы данных предлагают постоянное хранение, что означает, что ваши данные надежно сохранены и доступны даже после перезагрузки системы.
Доступность: Векторные базы данных обеспечивают постоянную доступность данных для запросов и извлечения в реальном времени. Это гарантирует, что даже по мере роста ваших данных вы по-прежнему сможете выполнять быстрый и эффективный поиск, позволяя принимать решения на основе ИИ без задержек.
Масштабируемость: По мере увеличения объема данных векторные базы данных эффективно масштабируются, чтобы обеспечить этот рост без снижения производительности. Это необходимо при управлении миллиардами точек неструктурированных данных.
Полное управление данными
Помимо вышеуказанных функций, векторные базы данных предоставляют надежные инструменты для управления вашими неструктурированными данными, включая прием данных, индексирование и выполнение запросов, что позволяет эффективно извлекать и анализировать даже самые крупные наборы данных. Такие функции, как резервное копирование и миграция, гарантируют, что ваши данные остаются защищенными и подлежат восстановлению, делая векторные базы данных надежным выбором для управления критически важной информацией.
Простота эксплуатации
Векторные базы данных также разработаны для упрощения развертывания и управления:
Развертывание в облаке или локально: Многие специализированные векторные базы данных универсальны и могут быть легко развернуты в публичных облаках или локальной инфраструктуре, обеспечивая гибкость в зависимости от потребностей организации.
Наблюдаемость: Многие векторные базы данных предлагают инструменты мониторинга для отслеживания состояния и производительности базы данных, позволяя пользователям проактивно оптимизировать свои системы.
Мультитенантность: Векторные базы данных, такие как Zilliz Cloud, поддерживают несколько пользователей или приложений, обеспечивая безопасный доступ и изолированную обработку данных для каждого тенанта. Это делает их идеальными для крупномасштабных развертываний, где нескольким командам нужны изолированные среды данных.
Роль Milvus в управлении неструктурированными данными
Milvus — это векторная база данных с открытым исходным кодом, предназначенная для эффективного хранения, индексирования и извлечения высокоразмерных векторов в масштабе миллиардов, что делает ее идеальной для сценариев использования, связанных с ИИ и машинным обучением, таких как рекомендательные системы, распознавание изображений или генерация с дополненным извлечением (RAG).
Milvus предлагает несколько вариантов развертывания для удовлетворения разнообразных потребностей клиентов.
Milvus с открытым исходным кодом: Открытый исходный код, самостоятельное управление и возможность размещения на любой машине при поддержке сообщества. Milvus также предлагает несколько вариантов развертывания для различных потребностей и сред, включая Milvus Lite, Milvus Standalone и Milvus Distributed. Подробнее см. в документации Milvus.
Zilliz Cloud: полностью управляемая версия Milvus, переработанная для облака и доступная в ведущих публичных облаках, таких как AWS, GCP и Azure.
Zilliz BYOC: готовый для предприятий Milvus для Private VPCs, который можно развернуть в вашем виртуальном частном облаке.
Рис. 1- Способы развертывания Milvus .png
Рис. 1: Способы развертывания Milvus
Ключевые возможности Milvus
Milvus разработан для высокой производительности и масштабируемости, предлагая такие возможности, как:
Рисунок- ключевые возможности Milvus .png
Рисунок: ключевые возможности Milvus
Мультитенантность: Milvus позволяет нескольким пользователям или приложениям работать в одной системе, не мешая друг другу, обеспечивая безопасный доступ к изолированным данным.
Аппаратно-ускоренные вычисления: оптимизирован для использования аппаратного обеспечения, такого как GPU, что делает его быстрее и эффективнее для ресурсоемких задач, таких как инференс моделей AI.
Поддержка языков и API: Milvus обладает высокой универсальностью, поддерживая Python, Java, Golang, NodeJS и т. д., что делает его доступным для широкого круга разработчиков.
Масштабируемая и эластичная архитектура: Milvus разработан для обработки растущих потребностей в данных. Он автоматически масштабируется в соответствии со спросом, обеспечивая оптимальную производительность по мере роста данных.
Поддержка разнообразных индексов: он поддерживает несколько типов индексов, включая HNSW, PQ, Binary и DiskANN, обеспечивая гибкость в том, как данные хранятся и ищутся.
Настраиваемая согласованность: Milvus позволяет настраивать уровни согласованности ваших данных, давая возможность балансировать между производительностью и точностью данных в зависимости от потребностей приложения.
Для получения более подробной информации обратитесь к документации Milvus.
Технологии, лежащие в основе Milvus для различных вариантов использования
Milvus работает на основе набора технологий, предназначенных для разных типов приложений, обеспечивая производительность, гибкость и масштабируемость в различных средах:
Рисунок- технологии Milvus для различных вариантов использования .png
Рисунок: технологии Milvus для различных вариантов использования
Типы вычислений: Milvus оптимизирован для различных аппаратных сред, включая AVX512 (набор инструкций CPU для высокоскоростных вычислений), Neon для SIMD (Single Instruction, Multiple Data) и GPU acceleration. Это гарантирует, что Milvus может использовать высокопроизводительное аппаратное обеспечение для обеспечения быстрой обработки и экономически эффективной масштабируемости.
Типы поиска: Milvus поддерживает широкий спектр методов поиска, таких как top-K ANN (Approximate Nearest Neighbors) для нахождения наиболее похожих точек данных, range ANN, sparse & dense searches и фильтрованный поиск. Они позволяют адаптировать функциональность поиска к конкретным потребностям наших приложений, будь то выявление похожих изображений, видео или текста.
Мультитенантность: Milvus поддерживает управление коллекциями и разделами, обеспечивая мультитенантность. Эта функция позволяет различным командам или приложениям совместно использовать одну и ту же базу данных, не вмешиваясь в данные друг друга, обеспечивая безопасную и изолированную обработку данных.
Типы индексов: Milvus предоставляет широкий спектр из 15 типов индексации, включая HNSW (Hierarchical Navigable Small Worlds) для высокоскоростного поиска, PQ (Product Quantization) для компактного хранения и DiskANN для работы с массивными наборами данных. Вы можете выбрать тип индексации, который лучше всего балансирует производительность, точность и стоимость в зависимости от вашего сценария использования.
Эти технологии делают Milvus хорошим выбором для широкого спектра приложений — от крупномасштабных облачных развертываний до периферийных устройств с ограниченными ресурсами.
Переход к периферийным вычислениям
По мере роста спроса на получение аналитических сведений из неструктурированных данных в реальном времени многие организации обнаруживают, что полагаться исключительно на облачные среды недостаточно. Это привело к переходу к периферийным вычислениям, при которых обработка выполняется ближе к месту генерации данных, что дает явные преимущества для чувствительных ко времени AI-приложений.
Периферийные вычисления — это практика обработки данных ближе к месту их генерации, часто на периферийных устройствах, таких как датчики, камеры и IoT-устройства. Вместо отправки необработанных данных обратно в централизованные центры обработки данных для обработки периферийные вычисления позволяют выполнять вычисления на самих устройствах или в близлежащих местах.
С ростом доступности мощных периферийных устройств стало возможно развертывать модели машинного обучения и AI непосредственно на этих устройствах. Такой подход обеспечивает принятие решений в реальном времени в таких приложениях, как автономные транспортные средства, умные города и промышленная автоматизация.
Почему стоит обрабатывать данные на периферии?
Обработка неструктурированных данных на периферии имеет несколько преимуществ:
Низкая задержка: Поскольку данные обрабатываются рядом с их источником, задержка при получении результатов минимальна.
Снижение нагрузки на пропускную способность: Обрабатывая данные локально, вы снижаете необходимость передавать большие объемы необработанных данных обратно в облако.
Конфиденциальность и безопасность: Конфиденциальные данные могут оставаться на периферийном устройстве, минимизируя риск раскрытия во время передачи.
Edge AI и векторные базы данных
Хотя периферийные вычисления приближают обработку данных к источнику на таких устройствах, как датчики, камеры и небольшие устройства вроде Raspberry Pi, именно векторная база данных по-настоящему дает этим устройствам возможность справляться с растущим потоком неструктурированных данных в реальном времени.
Например, в промышленной среде периферийные устройства отслеживают производительность оборудования и выявляют потенциальные проблемы с помощью данных датчиков. Векторная база данных, такая как Milvus, позволяет периферийному устройству быстро сравнивать входящие данные с историческими шаблонами, выявляя аномалии, которые указывают на необходимость обслуживания. Без векторной базы данных периферийному устройству пришлось бы либо отправлять все необработанные данные на облачный сервер для обработки (что приводит к задержкам и более высоким затратам), либо рисковать пропустить критически важные инсайты.
Milvus Lite: расширение возможностей периферийных устройств с помощью AI-возможностей
Milvus Lite — это облегченная версия Milvus, разработанная специально для сред с ограниченными ресурсами, таких как периферийные устройства. Она предоставляет все основные возможности векторной базы данных, но оптимизирована для развертывания на меньшем и менее мощном оборудовании. Это делает ее идеальным решением для расширения возможностей периферийных устройств, позволяя им выполнять сложные AI-задачи даже в средах с ограниченными ресурсами.
С Milvus Lite, работающим на edge-устройстве, устройство превращается в процессор данных на базе ИИ. Эта комбинация позволяет edge-устройству выполнять локальное распознавание изображений, поиск похожих видео или даже обработку естественного языка. Например, в розничной торговле умная кассовая система на базе Milvus Lite могла бы мгновенно распознавать товары и сопоставлять их с сохраненной векторной базой данных товаров, ускоряя транзакции без необходимости использования облачных систем.
Давайте рассмотрим практический пример, в котором Milvus обеспечивает работу edge-устройства на Raspberry Pi.
Создание системы оценки позы в реальном времени с Raspberry Pi и Milvus
Raspberry Pi — это серия небольших, доступных одноплатных компьютеров, разработанных Raspberry Pi Foundation. В этом примере мы будем использовать Raspberry Pi как edge-устройство и Milvus Lite для обработки неструктурированных данных.
Эта система оценки позы будет захватывать видеопотоки, обрабатывать их для оценки поз человека и сохранять извлеченные векторы признаков в Milvus для эффективного поиска по сходству. Кроме того, мы интегрируем Slack для уведомлений, чтобы получать оповещения при обнаружении определенных поз.
Вы можете посмотреть исходный код этого примера в блокноте Tim на GitHub.
Предварительные требования
Raspberry Pi (с установленными GStreamer и Python)
Учетная запись Slack для уведомлений
Импорт необходимых библиотек и начальная настройка
Начните с импорта необходимых библиотек и настройки некоторых начальных конфигураций:
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 ]
Приведенный выше код импортирует различные библиотеки для обработки видео (GStreamer), обработки изображений (OpenCV), глубокого обучения (PyTorch, timm), операций с базой данных (pymilvus) и коммуникации (Slack SDK). Он также импортирует библиотеку Hailo для работы с ИИ-ускорителем, предназначенным для запуска приложений глубокого обучения на edge-устройствах. Мы настраиваем глобальные переменные для конфигурации базы данных Milvus и определяем список моментов времени для периодических действий. MILVUSURL И TOKEN будут использоваться для аутентификации в облаке Zilliz.
Настройка базы данных Milvus
Далее мы настраиваем подключение к векторной базе данных Milvus. Мы будем использовать Milvus для хранения извлеченных признаков из модели оценки позы.
# Connect to Milvus
# Milvus Lite
# milvus_client = MilvusClient(uri="pipose.db")
# Облачный сервер
milvus_client = MilvusClient( uri=MILVUS_URL, token=TOKEN )
# Создать коллекцию Milvus, которая включает id, filepath изображения и 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)
Здесь мы настраиваем нашу базу данных Milvus. Мы создаем клиентское подключение, определяем схему для нашей коллекции (включая поля для ID, метки, позиций глаз, уверенности и вектора признаков), создаем коллекцию и настраиваем индекс для эффективного поиска по сходству.
Настройка Slack для уведомлений
Далее настройте подключение к Slack для отправки уведомлений:
slack_token = os.environ["SLACK_BOT_TOKEN"]
client = WebClient(token=slack_token)
Эта настройка позволит нам отправлять сообщения и файлы в Slack с использованием токена бота, сохраненного как переменная окружения.
Реализация экстрактора признаков
Нашей системе оценки поз требуется экстрактор признаков, чтобы преобразовывать обнаруженные позы в формат, подходящий для хранения в Milvus. Давайте определим класс для этого.
class FeatureExtractor:
def __init__(self, modelname):
# Загрузить предварительно обученную модель
self.model = timm.create_model(
modelname, pretrained=True, num_classes=0, global_pool="avg"
)
self.model.eval()
# Получить входной размер, требуемый моделью
self.input_size = self.model.default_cfg["input_size"]
config = resolve_data_config({}, model=modelname)
# Получить функцию предварительной обработки, предоставляемую TIMM для модели
self.preprocess = create_transform(**config)
def __call__(self, imagepath):
# Предварительно обработать входное изображение
input_image = Image.open(imagepath).convert("RGB") # Преобразовать в RGB при необходимости
input_image = self.preprocess(input_image)
# Преобразовать изображение в тензор PyTorch и добавить измерение batch
input_tensor = input_image.unsqueeze(0)
# Выполнить инференс
with torch.no_grad():
output = self.model(input_tensor)
# Извлечь вектор признаков
feature_vector = output.squeeze().numpy()
return normalize(feature_vector.reshape(1, -1), norm="l2").flatten()
extractor = FeatureExtractor("resnet34")
Этот класс FeatureExtractor будет преобразовывать наши изображения в векторы признаков. Для этой задачи мы используем предварительно обученную модель ResNet34. Метод __call__ открывает изображение, выполняет его предварительную обработку, пропускает его через модель и возвращает нормализованный вектор признаков.
Определение класса пользовательского callback
Продолжите и определите простой класс пользовательского callback.
class user_app_callback_class(app_callback_class):
def __init__(self):
super().__init__()
Этот класс наследуется от app_callback_class и не добавляет никакой новой функциональности. Это заполнитель, который позволяет в будущем настроить поведение callback.
Создание функции callback приложения
Функция app_callback выполняет большую часть обработки. Эта функция обрабатывает кадры видео, оценивает позы и сохраняет результаты в Milvus.
def app_callback(pad, info, user_data):
# Получить GstBuffer из информации probe
lefteye = ""
righteye = ""
buffer = info.get_buffer()
# Проверяем, действителен ли буфер
if buffer is None:
return Gst.PadProbeReturn.OK
# Используем user_data для подсчета количества кадров
user_data.increment()
string_to_print = f"Количество кадров: {user_data.get_count()}\n"
# Получаем caps из pad
format, width, height = get_caps_from_pad(pad)
# Если user_data.use_frame установлен в True, мы можем получить видеокадр из буфера
frame = None
if user_data.use_frame and format is not None and width is not None and height is not None:
# Получаем видеокадр
frame = get_numpy_from_buffer(buffer, format, width, height)
# Получаем обнаружения из буфера
roi = hailo.get_roi_from_buffer(buffer)
detections = roi.get_objects_typed(hailo.HAILO_DETECTION)
# Разбираем обнаружения
for detection in detections:
label = detection.get_label()
bbox = detection.get_bbox()
confidence = detection.get_confidence()
if label == "person":
string_to_print += (f"Обнаружение: {label} {confidence:.2f}\n")
# Ориентиры оценки позы из detection (если доступны)
landmarks = detection.get_objects_typed(hailo.HAILO_LANDMARKS)
if len(landmarks) != 0:
points = landmarks[0].get_points()
left_eye = points[1] # предполагаем, что 1 — это индекс левого глаза
right_eye = points[2] # предполагаем, что 2 — это индекс правого глаза
# Ориентиры нормализованы относительно ограничивающей рамки, также нужно преобразовать их к размеру кадра
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" Левый глаз: x: {left_eye_x:.2f} y: {left_eye_y:.2f} Правый глаз: x: {right_eye_x:.2f} y: {right_eye_y:.2f}\n")
if user_data.use_frame:
# Добавляем маркеры на кадр, чтобы показать ориентиры глаз
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:
# Преобразуем кадр в 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:
# Сохраняем изображение
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"Обнаружение: {label} {confidence:.2f}")
)
except SlackApiError as e:
# Вы получите SlackApiError, если "ok" равно False
assert e.response["error"]
try:
response = client.chat_postMessage(
channel="C06NE1FU6SE",
text=(f" Левый глаз: x: {left_eye_x:.2f} y: {left_eye_y:.2f} Правый глаз: x: {right_eye_x:.2f} y: {right_eye_y:.2f}\n")
)
except SlackApiError as e:
# Вы получите SlackApiError, если "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
Эта callback-функция обрабатывает видеокадры для обнаружения людей, сосредоточиваясь на извлечении таких деталей, как ограничивающая рамка, confidence и ориентиры глаз. Она отмечает обнаруженные позиции глаз в кадре и сохраняет изображение кадра, если в кадре есть человек. Кроме того, она отправляет уведомления в Slack с деталями обнаружения и размеченным изображением. Затем функция извлекает вектор embedding из сохраненного изображения. Она обновляет Milvus этими данными, включая embedding (vector), координаты глаз (lefteye и righteye), метку объекта (label) и confidence обнаружения (confidence).
Создание служебной функции для COCO Keypoints
Создайте служебную функцию для получения COCO keypoints. Это определенные точки на теле человека, которые используются для оценки позы.
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
Эта функция возвращает словарь, сопоставляющий части тела с соответствующими индексами keypoint в формате набора данных COCO.
Создание GStreamer Pipeline
Продолжайте и создайте основной класс приложения, который настроит GStreamer pipeline. Это последовательность элементов, которые обрабатывают мультимедийные данные в определенном порядке. Он будет обрабатывать live video streams.
# 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
Этот класс настраивает наш конвейер GStreamer. Он запускает модель оценки позы на Raspberry Pi с использованием AI-ускорителя Hailo, который представляет собой edge AI-процессор, предназначенный для выполнения задач глубокого обучения и AI-инференса на edge-устройствах. Он инициализирует такие параметры, как размер батча, размеры входных данных, цветовой формат и пути к файлам модели нейронной сети и постобработки. В зависимости от источника входных данных (например, камера Raspberry Pi, USB-камера или видеофайл) он строит конвейер GStreamer для захвата видео, обработки его через модель Hailo, применения постобработки и отображения результата. Конфигурация конвейера задается в методе get_pipeline_string, который собирает элементы GStreamer, необходимые для этой задачи.
Выполнение программы
Последний шаг — выполнение программы.
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()
Здесь мы соединяем всё воедино. Мы создаем экземпляр нашего user_app_callback_class, разбираем любые аргументы командной строки, создаем наш GStreamerPoseEstimationApp и запускаем его.
Вот пример результата, которого следует ожидать при запуске программы.
Fig 2- Output of a pose estimation program in Slack with eye landmarks marked with green dots.png
Рис. 2: Вывод программы оценки позы в Slack с ориентирами глаз, отмеченными зелеными точками
Это обновление в Slack, когда обнаружен человек. Оно содержит оценку уверенности 81%, координаты левого и правого глаза, а также изображение с отмеченными ориентирами глаз (зеленые круги в позициях левого и правого глаза).
Варианты использования сочетания ИИ и векторных баз данных
Сочетание периферийного ИИ и векторных баз данных открывает множество вариантов использования. Ниже приведены некоторые примеры.
Робототехника
Периферийный ИИ и векторные базы данных расширяют возможности автономных роботов, позволяя им обрабатывать данные датчиков локально и мгновенно принимать решения. Эта технология значительно повышает эффективность и адаптивность в динамичных средах.
Пример: В автоматизации складов автономные мобильные роботы (AMR) используют бортовые камеры и локальные векторные базы данных для распознавания объектов в реальном времени. Перемещаясь по складу, эти роботы мгновенно идентифицируют и классифицируют товары, сравнивая визуальные данные с локально сохраненными векторами. Это позволяет им адаптироваться к меняющимся условиям склада и оптимизировать свои маршруты без необходимости полагаться на облачную инфраструктуру.
Умные города
Периферийный ИИ и векторные базы данных играют ключевую роль в оптимизации городских операций — от управления дорожным движением до общественной безопасности. Эти технологии обеспечивают быструю обработку данных и принятие решений на периферии, повышая эффективность города и качество жизни жителей.
Пример: Интеллектуальные системы управления дорожным движением используют периферийный ИИ для локальной обработки видеопотоков с камер на перекрестках. Система преобразует схемы дорожного движения в векторные представления и сравнивает их с историческими данными, хранящимися в локальной векторной базе данных. Это позволяет в реальном времени корректировать работу светофоров для снижения заторов, обеспечивая быстрое время реакции без необходимости постоянной передачи данных на центральные серверы.
Промышленная автоматизация
Периферийный ИИ и векторные базы данных способствуют предиктивному обслуживанию и мониторингу оборудования в производственных и промышленных средах. Такой подход позволяет в реальном времени анализировать состояние машин, предотвращая простои и оптимизируя производственные процессы.
Пример: Умные производственные предприятия устанавливают датчики на критически важное оборудование для непрерывного сбора данных о вибрации. Периферийные устройства преобразуют эти данные в векторные представления и сравнивают их с известными «здоровыми» и «неисправными» вибрационными паттернами, хранящимися в локальной векторной базе данных. Этот анализ в реальном времени позволяет немедленно обнаруживать потенциальные отказы оборудования, способствуя проактивному обслуживанию и минимизируя дорогостоящие сбои.
Здравоохранение
Периферийный ИИ и векторные базы данных преобразуют уход за пациентами, обеспечивая непрерывный мониторинг здоровья без ущерба для конфиденциальности. Эти технологии позволяют выполнять сложный анализ медицинских данных непосредственно на носимых устройствах или локальных системах.
Пример: Носимые ЭКГ-мониторы используют периферийный ИИ для локальной обработки данных сердечного ритма. Устройство преобразует ЭКГ-паттерны в векторы и сравнивает их с базой данных нормальных и аномальных ритмов, хранящейся на борту. Такой подход позволяет немедленно обнаруживать потенциальные сердечные проблемы, сохраняя при этом конфиденциальные медицинские данные на устройстве, повышая как оперативность реагирования, так и конфиденциальность пациента.
Заключение
По мере того как неструктурированные данные растут в масштабе и значимости, эффективные решения для их обработки становятся всё более важными. Тим хорошо показал преобразующий потенциал векторных баз данных, таких как Milvus, предлагающих расширенные возможности как для облачных, так и для периферийных развертываний. Будь то крупномасштабные AI-приложения или периферийные устройства с ограниченными ресурсами, Milvus и его облегчённый аналог, Milvus Lite, позволяют организациям использовать неструктурированные данные для принятия решений в реальном времени, инноваций и операционной эффективности. Благодаря гибкости масштабирования от облака до периферии эти технологии находятся на переднем крае современных решений на базе AI.
Дополнительные ресурсы
AI-проекты Тима на GitHub:
Обработка неструктурированных данных с помощью Raspberry Pi AI Kit
Читать далее
My Wife Wanted Dior. I Spent $600 on Claude Code to Vibe-Code a 2M-Line Database Instead.
Write tests, not code reviews. How a test-first workflow with 6 parallel Claude Code sessions turns a 2M-line C++ codebase into a daily shipping pipeline.
Zilliz Cloud BYOC Now Available Across AWS, GCP, and Azure
Zilliz Cloud BYOC is now generally available on all three major clouds. Deploy fully managed vector search in your own AWS, GCP, or Azure account — your data never leaves your VPC.
Proactive Monitoring for Vector Database: Zilliz Cloud Integrates with Datadog
we're excited to announce Zilliz Cloud's integration with Datadog, enabling comprehensive monitoring and observability for your vectorDB deployments.