Premiers pas avec PyMilvus
Milvus, une base de données vectorielle open source, associée à PyMilvus - son SDK Python, est un outil puissant pour gérer de grands ensembles de données et effectuer des calculs et des recherches avancés.
Ce tutoriel vous guidera dans l’installation et la configuration d’un environnement de développement pour utiliser Milvus et PyMilvus. Ensuite, vous parcourrez un exemple de code pour analyser des fichiers audio, stocker leurs données dans Milvus, puis les utiliser pour comparer des échantillons audio afin de détecter des similarités. Commençons.
Qu’est-ce que Milvus ?
Milvus est une base de données vectorielle open source qui prend en charge la recherche et l’analytique de similarité vectorielle à l’échelle du billion. C’est une plateforme puissante et efficace pour gérer et rechercher des données non structurées au moyen de vecteurs d’embedding, une capacité de plus en plus importante dans l’apprentissage automatique, la vision par ordinateur, les systèmes de recommandation et d’autres domaines de l’intelligence artificielle (IA).
À la base, Milvus exploite le concept d’embeddings, où les points de données sont représentés sous forme de vecteurs de haute dimension. Ces vecteurs peuvent capturer la similarité entre les points de données en fonction de leurs caractéristiques sémantiques ou visuelles. Milvus permet le stockage, l’indexation et la récupération de ces vecteurs, permettant aux utilisateurs d’effectuer des recherches de similarité rapides sur d’immenses ensembles de données.
Grâce à son architecture distribuée et à la prise en charge de l’accélération GPU, Milvus peut traiter efficacement de grands volumes de données vectorielles et fournir des résultats de recherche en temps réel. En outre, il propose une gamme d’algorithmes d’indexation optimisés pour différents cas d’utilisation, notamment des algorithmes de recherche approximative du plus proche voisin (ANN), afin d’équilibrer précision et efficacité.
Milvus prend en charge divers langages de programmation et fournit des API faciles à utiliser, ce qui le rend accessible aux développeurs et aux chercheurs. En outre, il s’intègre bien aux frameworks d’apprentissage automatique et aux outils de traitement des données populaires, permettant une intégration fluide dans les workflows existants.
Qu’est-ce que PyMilvus ?
PyMilvus est le SDK Python pour Milvus. Il est conçu pour permettre aux développeurs Python d’interagir avec Milvus facilement et efficacement, en facilitant des tâches telles que la gestion des données, la réalisation de recherches de similarité vectorielle, la création d’index, et plus encore.
Avec PyMilvus, les développeurs exploitent toute la puissance de Milvus dans leurs applications Python sans avoir à se soucier des subtilités des opérations de base de données sous-jacentes. Il fait abstraction de nombreuses complexités liées au travail avec Milvus, en fournissant une API simple et facile à utiliser qui s’intègre parfaitement aux workflows Python existants.
Configuration pour le tutoriel
Les exemples en ligne de commande dans cet article proviendront de Linux, mais ils devraient se transposer facilement à macOS ou Windows avec le Sous-système Windows pour Linux (WSL). Vous aurez besoin d’un système avec Docker ou Docker Desktop, Python 3.10+, et git.
Dépôt Milvus bootcamp
Nous allons utiliser le code du dépôt Milvus Bootcamp sur Github pour ce tutoriel. Commencez par cloner le dépôt sur votre système local.
[egoebelbecker@ares bootcamp]$ git clone https://github.com/milvus-io/bootcamp.git
Cloning into 'bootcamp'...
remote: Enumerating objects: 61861, done.
remote: Counting objects: 100% (4488/4488), done.
remote: Compressing objects: 100% (1628/1628), done.
remote: Total 61861 (delta 2983), reused 4180 (delta 2791), pack-reused 57373
Receiving objects: 100% (61861/61861), 166.78 MiB | 4.91 MiB/s, done.
Resolving deltas: 100% (28214/28214), done.
Environnement virtuel Python
Ensuite, créez un environnement virtuel pour exécuter votre code. Vous pouvez le placer dans le répertoire où vous avez cloné le dépôt bootcamp. Activez l’environnement après l’avoir créé.
[egoebelbecker@ares bootcamp]$ cd bootcamp
[egoebelbecker@ares bootcamp]$ git checkout archive20230625
[egoebelbecker@ares bootcamp]$ python3 -m venv ./venv
[egoebelbecker@ares bootcamp]$ source venv/bin/activate
(venv) [egoebelbecker@ares bootcamp]$
Installer les dépendances Python
Il est maintenant temps de configurer notre projet.
Nous allons utiliser l'exemple Audio Similarity Search. Il utilise un ensemble de fichiers audio accessible au public pour démontrer comment vous pouvez utiliser Milvus afin de détecter des similarités entre différents échantillons.
Accédez au sous-répertoire du projet et consultez le fichier requirements.txt fourni avec le code.
(venv) [egoebelbecker@ares bootcamp]$ cd solutions/audio/audio_similarity_search/
(venv) [egoebelbecker@ares audio_similarity_search]$ cat requirements.txt
pymilvus
redis
librosa
numpy
panns_inference
torch
diskcache
gdown
Ce sont les bibliothèques Python nécessaires pour exécuter le projet. Utilisez pip pour les installer. Ensuite, ajoutez Jupyter afin que nous puissions exécuter le notebook.
(venv) [egoebelbecker@ares audio_similarity_search]$ pip install -r requirements.txt
(Lots of output)
(venv) [egoebelbecker@ares audio_similarity_search]$ pip install jupyter
(More output)
Démarrer Redis
Maintenant, démarrez un conteneur Docker Redis.
docker run --name redis -d -p 6379:6379 redis
Installer et démarrer Milvus Lite
Enfin, vous aurez besoin d'un serveur Milvus. Le moyen le plus simple de démarrer avec Milvus est Milvus Lite, qui s'exécute en Python. Installez les packages milvus.
(venv) [egoebelbecker@ares audio_similarity_search]$ pip install milvus
(Lots of output)
(venv) [egoebelbecker@ares audio_similarity_search]$ milvus-server
__ _________ _ ____ ______
/ |/ / _/ /| | / / / / / __/
/ /|_/ // // /_| |/ / /_/ /\ \
/_/ /_/___/____/___/\____/___/ {Lite}
Welcome to use Milvus!
Version: v2.2.8-lite
Process: 275118
Started: 2023-05-25 12:41:47
Config: /home/egoebelbecker/.milvus.io/milvus-server/2.2.8/configs/milvus.yaml
Logs: /home/egoebelbecker/.milvus.io/milvus-server/2.2.8/logs
Ctrl+C to exit ...
Projet PyMilvus
Maintenant qu'un environnement est configuré, vous pouvez exécuter le tutoriel.
Démarrer Jupyter
Démarrez Jupyter depuis votre environnement virtuel.
(venv) [egoebelbecker@ares audio_similarity_search]$ python -m jupyter notebook --notebook-dir=`pwd`
_ _ _ _
| | | |_ __ __| |__ _| |_ ___
| |_| | '_ \/ _` / _` | _/ -_)
\___/| .__/\__,_\__,_|\__\___|
|_|
Read the migration plan to Notebook 7 to learn about the new features and the actions to take if you are using extensions.
https://jupyter-notebook.readthedocs.io/en/latest/migrate_to_notebook7.html
(More output)
Cela ouvrira la page Fichiers Jupyter dans votre navigateur par défaut.
Accédez au répertoire solutions/audio/audio_similarity_search.
Ouvrez le notebook audio_similarity_search.
Se connecter à Redis et Milvus
Vous avez déjà effectué la configuration initiale, alors faites défiler directement jusqu'à la section Code Overview. Le code commence par importer des bibliothèques pour Redis et Milvus.
Sur la deuxième ligne, vous pouvez voir les classes dont vous aurez besoin pour vous connecter à Milvus, créer une Collection, ainsi qu'y ajouter et en récupérer des données.
import redis
from pymilvus import connections, DataType, FieldSchema, CollectionSchema, Collection, utility
connections.connect(host = '127.0.0.1', port = 19530)
red = redis.Redis(host = '127.0.0.1', port=6379, db=0)
Ensuite, le code se connecte aux deux serveurs. Exécutez ce bloc. Maintenant, il est temps de créer une collection Milvus pour stocker les informations sur chaque fichier audio.
import time
red.flushdb()
time.sleep(.1)
collection_name = "audio_test_collection"
if utility.has_collection(collection_name):
print("Dropping existing collection...")
collection = Collection(name=collection_name)
collection.drop()
#if not utility.has_collection(collection_name):
field1 = FieldSchema(name="id", dtype=DataType.INT64, description="int64", is_primary=True,auto_id=True)
field2 = FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, description="float vector", dim=2048, is_primary=False)
schema = CollectionSchema(fields=[ field1,field2], description="collection description")
collection = Collection(name=collection_name, schema=schema)
print("Created new collection with name: " + collection_name)
Créer une collection Milvus
Cette étape crée une collection nommée audio_test_collection avec deux champs :
- id - un champ d’identification entier
- embedding - un vecteur de 2048 nombres à virgule flottante pour stocker des données sur les fichiers audio
Exécutez ce bloc et vous verrez ce message :
Dropping existing collection...
Created new collection with name: audio_test_collection
Ensuite, ajoutez un index à votre nouvelle collection :
if utility.has_collection(collection_name):
collection = Collection(name = collection_name)
default_index = {"index_type": "IVF_SQ8", "metric_type": "L2", "params": {"nlist": 16384}}
status = collection.create_index(field_name = "embedding", index_params = default_index)
if not status.code:
print("Successfully create index in collection:{} with param:{}".format(collection_name, default_index))
Exécutez ce bloc :
Successfully create index in collection:audio_test_collection with param:{'index_type': 'IVF_SQ8', 'metric_type': 'L2', 'params': {'nlist': 16384}}
Stocker des données audio
Milvus est maintenant prêt à stocker les données audio. Décomposons le prochain bloc de code et examinons-le de près.
import os
import librosa
import gdown
import zipfile
import numpy as np
from panns_inference import SoundEventDetection, labels, AudioTagging
data_dir = './example_audio'
at = AudioTagging(checkpoint_path=None, device='cpu')
def download_audio_data():
url = 'https://drive.google.com/uc?id=1bKu21JWBfcZBuEuzFEvPoAX6PmRrgnUp'
gdown.download(url)
with zipfile.ZipFile('example_audio.zip', 'r') as zip_ref:
zip_ref.extractall(data_dir)
Cette section importe des bibliothèques pour le traitement des fichiers. Ensuite, elle crée un objet AudioTagging à partir de la bibliothèque Panns Inference.
Il s’agit d’une interface Python pour les Large-Scale Pretrained Audio Neural Networks for Audio Pattern Recognition (PANNs).
La classe AudioTagging créera un ensemble de points de données pour chaque fichier audio, similaire à ceci :
Speech: 0.893
Telephone bell ringing: 0.754
Inside, small room: 0.235
Telephone: 0.183
Music: 0.092
Ringtone: 0.047
Inside, large room or hall: 0.028
Alarm: 0.014
Animal: 0.009
Vehicle: 0.008
embedding: (2048,)
Vient ensuite le code pour télécharger les fichiers, les analyser et insérer les données dans Milvus, ainsi que les informations de fichier dans Redis :
def embed_and_save(path, at):
audio, _ = librosa.core.load(path, sr=32000, mono=True)
audio = audio[None, :]
try:
_, embedding = at.inference(audio)
embedding = embedding/np.linalg.norm(embedding)
embedding = embedding.tolist()[0]
mr = collection.insert([[embedding]])
ids = mr.primary_keys
collection.load()
red.set(str(ids[0]), path)
except Exception as e:
print("failed: " + path + "; error {}".format(e))
Ce bloc de code rassemble le tout :
print("Starting Insert")
download_audio_data()
for subdir, dirs, files in os.walk(data_dir):
for file in files:
path = os.path.join(subdir, file)
embed_and_save(path, at)
print("Insert Done")
Exécutez le code :
Checkpoint path: /home/egoebelbecker/panns_data/Cnn14_mAP=0.431.pth
Using CPU.
Starting Insert
Téléchargement...
Depuis : [https://drive.google.com/uc?id=1bKu21JWBfcZBuEuzFEvPoAX6PmRrgnUp](https://drive.google.com/uc?id=1bKu21JWBfcZBuEuzFEvPoAX6PmRrgnUp)
Vers : /home/egoebelbecker/src/bootcamp/solutions/audio/audio_similarity_search/example_audio.zip
100%|█████████████████████████████████████████████████████████████████████████████████████████| 474k/474k [00:00<00:00, 8.87MB/s]
Insertion terminée
Rechercher des similarités
Pour rechercher dans la base de données, vous devez effectuer la même analyse sur les fichiers que vous devez faire correspondre. Voici du code pour le faire sur un ensemble d’identifiants de fichiers sélectionnés aléatoirement.
```python
def get_embed(paths, at):
embedding_list = []
for x in paths:
audio, _ = librosa.core.load(x, sr=32000, mono=True)
audio = audio[None, :]
try:
_, embedding = at.inference(audio)
embedding = embedding/np.linalg.norm(embedding)
embedding_list.append(embedding)
except:
print("Embedding Failed: " + x)
return np.array(embedding_list, dtype=np.float32).squeeze()
random_ids = [int(red.randomkey()) for x in range(2)]
search_clips = [x.decode("utf-8") for x in red.mget(random_ids)]
embeddings = get_embed(search_clips, at)
print(embeddings.shape)
Exécutez ce bloc pour sélectionner deux fichiers et lancer l’analyse. Maintenant, il est temps d’effectuer une recherche dans Milvus. Ce code affiche les résultats de recherche dans des lecteurs audio :
import IPython.display as ipd
def show_results(query, results, distances):
print("Query: ")
ipd.display(ipd.Audio(query))
print("Results: ")
for x in range(len(results)):
print("Distance: " + str(distances[x]))
ipd.display(ipd.Audio(results[x]))
print("-"*50)
Ensuite, le programme prend le tableau embeddings construit ci-dessus et le convertit en liste. Puis il crée nos paramètres de recherche. Nous recherchons deux sons similaires et utilisons nprobe comme critère. Cela correspond au type d’index que vous avez utilisé ci-dessus.
embeddings_list = embeddings.tolist()
search_params = {"metric_type": "L2", "params": {"nprobe": 16}}
Enfin, voici la recherche.
try:
start = time.time()
results = collection.search(embeddings_list, anns_field="embedding", param=search_params, limit=3)
end = time.time() - start
print("Search took a total of: ", end)
for x in range(len(results)):
query_file = search_clips[x]
result_files = [red.get(y.id).decode('utf-8') for y in results[x]]
distances = [y.distance for y in results[x]]
show_results(query_file, result_files, distances)
except Exception as e:
print("Failed to search vectors in Milvus: {}".format(e))
Exécutez-le, et vous verrez les fichiers sélectionnés aléatoirement ainsi que deux résultats de recherche, avec leur distance par rapport à l’original.
Écoutez chaque fichier, et vous entendrez la correspondance exacte et son voisin le plus proche.
Résumé
Dans cet article, vous avez appris à créer un environnement Python pour travailler avec Milvus. Après avoir configuré un serveur et le SDK PyMilvus, vous avez exécuté un tutoriel d’exemple depuis le dépôt Milvus Bootcamp. Vous avez vu du code pour créer une collection, l’indexer, stocker des données et effectuer une recherche de base.
Maintenant que vous avez vu à quel point il est facile de démarrer avec Milvus, poursuivez avec les projets du bootcamp et découvrez comment vous pouvez utiliser Milvus pour améliorer vos projets.
Cet article a été écrit par Eric Goebelbecker. Eric a travaillé sur les marchés financiers à New York pendant 25 ans, développant des infrastructures pour les données de marché et les réseaux du protocole Financial Information Exchange (FIX). Il adore parler de ce qui rend les équipes efficaces (ou moins efficaces !).
Continuer à lire
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.
Build for the Boom: Why AI Agent Startups Should Build Scalable Infrastructure Early
Explore strategies for developing AI agents that can handle rapid growth. Don't let inadequate systems undermine your success during critical breakthrough moments.
AI Integration in Video Surveillance Tools: Transforming the Industry with Vector Databases
Discover how AI and vector databases are revolutionizing video surveillance with real-time analysis, faster threat detection, and intelligent search capabilities for enhanced security.