Introduzione a PyMilvus
Milvus, un database vettoriale open-source, abbinato a PyMilvus - il suo SDK Python, è uno strumento potente per gestire grandi set di dati ed eseguire calcoli e ricerche avanzati.
Questo tutorial ti guiderà nell'installazione e nella configurazione di un ambiente di sviluppo per usare Milvus e PyMilvus. Poi, esaminerai un codice di esempio per analizzare file audio, archiviare i loro dati in Milvus e quindi usarli per confrontare campioni audio in base alle somiglianze. Cominciamo.
Che cos'è Milvus?
Milvus è un database vettoriale open-source che gestisce ricerca e analisi di similarità vettoriale su scala di trilioni. È una piattaforma potente ed efficiente per gestire e cercare dati non strutturati tramite vettori di embedding, una capacità sempre più importante nell'apprendimento automatico, nella visione artificiale, nei sistemi di raccomandazione e in altri ambiti dell'intelligenza artificiale (AI).
Alla base, Milvus sfrutta il concetto di embedding, in cui i punti dati sono rappresentati come vettori ad alta dimensionalità. Questi vettori possono catturare la similarità tra punti dati in base alle loro caratteristiche semantiche o visive. Milvus consente l'archiviazione, l'indicizzazione e il recupero di questi vettori, permettendo agli utenti di eseguire rapide ricerche di similarità su enormi set di dati.
Con la sua architettura distribuita e il supporto per l'accelerazione GPU, Milvus può elaborare in modo efficiente grandi volumi di dati vettoriali e fornire risultati di ricerca in tempo reale. Inoltre, offre una gamma di algoritmi di indicizzazione ottimizzati per diversi casi d'uso, inclusi algoritmi di ricerca del vicino più prossimo approssimata (ANN), per bilanciare accuratezza ed efficienza.
Milvus supporta vari linguaggi di programmazione e fornisce API facili da usare, rendendolo accessibile a sviluppatori e ricercatori. Inoltre, si integra bene con framework di apprendimento automatico e strumenti di elaborazione dati popolari, consentendo un'integrazione fluida nei flussi di lavoro esistenti.
Che cos'è PyMilvus?
PyMilvus è l'SDK Python per Milvus. È progettato per consentire agli sviluppatori Python di interagire con Milvus in modo semplice ed efficiente, facilitando attività come la gestione dei dati, l'esecuzione di ricerche di similarità vettoriale, la creazione di indici e altro ancora.
Con PyMilvus, gli sviluppatori sfruttano tutta la potenza di Milvus nelle loro applicazioni Python senza doversi preoccupare delle complessità delle operazioni del database sottostante. Astrae molte delle complessità del lavoro con Milvus, fornendo un'API semplice e facile da usare che si integra perfettamente con i flussi di lavoro Python esistenti.
Configurazione per il tutorial
Gli esempi da riga di comando in questo post saranno da Linux, ma dovrebbero essere facilmente adattabili a macOS o Windows con Windows Subsystem for Linux (WSL). Avrai bisogno di un sistema con Docker o Docker Desktop, Python 3.10+ e git.
Repository Milvus bootcamp
Useremo il codice dal repository Milvus Bootcamp su Github per questo tutorial. Inizia clonando il repo sul tuo sistema locale.
[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.
Ambiente virtuale Python
Successivamente, crea un ambiente virtuale per eseguire il tuo codice. Puoi metterlo nella directory in cui hai clonato il repo bootcamp. Attiva l'ambiente dopo averlo creato.
[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]$
Installa le dipendenze Python
Ora è il momento di configurare il nostro progetto.
Useremo l'esempio Audio Similarity Search. Utilizza un set di file audio disponibile pubblicamente per dimostrare come puoi usare Milvus per rilevare somiglianze tra campioni diversi.
Spostati nella sottodirectory del progetto e guarda il file requirements.txt fornito con il codice.
(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
Queste sono le librerie Python necessarie per eseguire il progetto. Usa pip per installarle. Poi, aggiungi Jupyter così possiamo eseguire il 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)
Avvia Redis
Ora, avvia un container Docker Redis.
docker run --name redis -d -p 6379:6379 redis
Installa e avvia Milvus Lite
Infine, ti servirà un server Milvus. Il modo più semplice per iniziare a usare Milvus è Milvus Lite, che viene eseguito in Python. Installa i pacchetti 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 ...
Progetto PyMilvus
Ora, con un ambiente configurato, puoi eseguire il tutorial.
Avvia Jupyter
Avvia Jupyter dal tuo ambiente virtuale.
(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)
Questo aprirà la pagina Jupyter Files nel tuo browser predefinito.
Vai alla directory solutions/audio/audio_similarity_search.
Apri il notebook audio_similarity_search.
Connettiti a Redis e Milvus
Hai già completato la configurazione iniziale, quindi scorri direttamente fino alla sezione Code Overview. Il codice inizia importando le librerie per Redis e Milvus.
Nella seconda riga, puoi vedere le classi di cui avrai bisogno per connetterti a Milvus, creare una Collection e aggiungere e recuperare dati da essa.
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)
Poi, il codice si connette ai due server. Esegui questo blocco. Ora è il momento di creare una collection Milvus per memorizzare le informazioni su ciascun file 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)
Crea una Collection Milvus
Questo passaggio crea una collection denominata audio_test_collection con due campi:
- id - un campo di identificazione intero
- embedding - un vettore di 2048 numeri in virgola mobile per archiviare dati sui file audio
Esegui questo blocco e vedrai questo messaggio:
Dropping existing collection...
Created new collection with name: audio_test_collection
Successivamente, aggiungi un indice alla tua nuova 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))
Esegui questo blocco:
Successfully create index in collection:audio_test_collection with param:{'index_type': 'IVF_SQ8', 'metric_type': 'L2', 'params': {'nlist': 16384}}
Archiviare dati audio
Milvus è ora pronto per archiviare i dati audio. Scomponiamo il prossimo blocco di codice e osserviamolo da vicino.
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)
Questa sezione importa le librerie per l'elaborazione dei file. Poi. crea un oggetto AudioTagging dalla libreria Panns Inference.
Questa è un'interfaccia Python per le Large-Scale Pretrained Audio Neural Networks for Audio Pattern Recognition (PANNs).
La classe AudioTagging creerà un insieme di punti dati per ogni file audio, simile a questo:
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,)
Segue il codice per scaricare i file, analizzarli e inserire i dati in Milvus, e le informazioni sui file in 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))
Questo blocco di codice mette tutto insieme:
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")
Esegui il codice:
Checkpoint path: /home/egoebelbecker/panns_data/Cnn14_mAP=0.431.pth
Using CPU.
Starting Insert
Download in corso...
Da: [https://drive.google.com/uc?id=1bKu21JWBfcZBuEuzFEvPoAX6PmRrgnUp](https://drive.google.com/uc?id=1bKu21JWBfcZBuEuzFEvPoAX6PmRrgnUp)
A: /home/egoebelbecker/src/bootcamp/solutions/audio/audio_similarity_search/example_audio.zip
100%|█████████████████████████████████████████████████████████████████████████████████████████| 474k/474k [00:00<00:00, 8.87MB/s]
Inserimento completato
Cerca somiglianze
Per cercare nel database, devi eseguire la stessa analisi sui file che devi confrontare. Ecco il codice per farlo su un insieme selezionato casualmente di id di file.
```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)
Esegui questo blocco per selezionare due file ed eseguire l'analisi. Ora è il momento di eseguire una ricerca in Milvus. Questo codice visualizza i risultati della ricerca in lettori 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)
Successivamente, il programma prende l'array embeddings creato sopra e lo converte in una lista. Poi crea i nostri parametri di ricerca. Stiamo cercando due suoni simili e usando nprobe per i criteri. Questo corrisponde al tipo di indice che hai usato sopra.
embeddings_list = embeddings.tolist()
search_params = {"metric_type": "L2", "params": {"nprobe": 16}}
Infine, ecco la ricerca.
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))
Eseguilo e vedrai i file selezionati casualmente e due risultati di ricerca, con la loro distanza dall'originale.
Ascolta ogni file e sentirai la corrispondenza esatta e il suo vicino più prossimo.
Riepilogo
In questo post, hai imparato a creare un ambiente Python per lavorare con Milvus. Dopo aver configurato un server e l'SDK PyMilvus, hai eseguito un tutorial di esempio dal repository Milvus Bootcamp. Hai visto il codice per creare una collection, indicizzarla, archiviare dati ed eseguire una ricerca di base.
Ora che hai visto quanto è facile iniziare con Milvus, continua con i progetti del bootcamp e scopri come puoi usare Milvus per migliorare i tuoi progetti.
Questo post è stato scritto da Eric Goebelbecker. Eric ha lavorato nei mercati finanziari a New York City per 25 anni, sviluppando infrastrutture per i dati di mercato e reti basate sul protocollo Financial Information Exchange (FIX). Ama parlare di ciò che rende i team efficaci (o non così efficaci!).
Continua a leggere
Introducing Business Critical Plan: Enterprise-Grade Security and Compliance for Mission-Critical AI Applications
Discover Zilliz Cloud’s Business Critical Plan—offering advanced security, compliance, and uptime for mission-critical AI and vector database workloads.
Similarity Metrics for Vector Search
Exploring five similarity metrics for vector search: L2 or Euclidean distance, cosine distance, inner product, and hamming distance.
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.