Primeros pasos con PyMilvus
Milvus, una base de datos vectorial de código abierto, junto con PyMilvus, su SDK de Python, es una herramienta potente para manejar grandes conjuntos de datos y realizar cálculos y búsquedas avanzados.
Este tutorial te guiará en la instalación y configuración de un entorno de desarrollo para usar Milvus y PyMilvus. Luego, recorrerás código de ejemplo para analizar archivos de audio, almacenar sus datos en Milvus y después usarlo para comparar muestras de audio en busca de similitudes. Empecemos.
¿Qué es Milvus?
Milvus es una base de datos vectorial de código abierto que maneja búsquedas y análisis de similitud vectorial a escala de billones. Es una plataforma potente y eficiente para gestionar y buscar datos no estructurados mediante vectores de incrustación, una capacidad cada vez más importante en aprendizaje automático, visión por computadora, sistemas de recomendación y otros campos de la inteligencia artificial (IA).
En esencia, Milvus aprovecha el concepto de incrustaciones, donde los puntos de datos se representan como vectores de alta dimensión. Estos vectores pueden capturar la similitud entre puntos de datos en función de sus características semánticas o visuales. Milvus permite el almacenamiento, la indexación y la recuperación de estos vectores, lo que permite a los usuarios realizar búsquedas rápidas de similitud en conjuntos de datos masivos.
Con su arquitectura distribuida y soporte para aceleración por GPU, Milvus puede procesar eficientemente grandes volúmenes de datos vectoriales y entregar resultados de búsqueda en tiempo real. Además, ofrece una variedad de algoritmos de indexación optimizados para diferentes casos de uso, incluidos algoritmos de búsqueda aproximada del vecino más cercano (ANN), para equilibrar precisión y eficiencia.
Milvus admite varios lenguajes de programación y proporciona API fáciles de usar, lo que lo hace accesible para desarrolladores e investigadores. Además, se integra bien con marcos populares de aprendizaje automático y herramientas de procesamiento de datos, lo que permite una integración fluida en flujos de trabajo existentes.
¿Qué es PyMilvus?
PyMilvus es el SDK de Python para Milvus. Está diseñado para permitir que los desarrolladores de Python interactúen con Milvus de forma fácil y eficiente, facilitando tareas como gestionar datos, realizar búsquedas de similitud vectorial, construir índices y más.
Con PyMilvus, los desarrolladores aprovechan toda la potencia de Milvus en sus aplicaciones de Python sin tener que preocuparse por los entresijos de las operaciones subyacentes de la base de datos. Abstrae muchas de las complejidades de trabajar con Milvus, proporcionando una API sencilla y fácil de usar que se integra sin problemas con los flujos de trabajo existentes de Python.
Configuración para el tutorial
Los ejemplos de línea de comandos en esta publicación serán de Linux, pero deberían adaptarse fácilmente a macOS o Windows con el Subsistema de Windows para Linux (WSL). Necesitarás un sistema con Docker o Docker Desktop, Python 3.10+ y git.
Repositorio Milvus bootcamp
Vamos a usar código del repositorio Milvus Bootcamp en Github para este tutorial. Comienza clonando el repositorio en tu sistema 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.
Entorno virtual de Python
A continuación, crea un entorno virtual para ejecutar tu código. Puedes colocarlo en el directorio donde clonaste el repositorio bootcamp. Activa el entorno después de haberlo creado.
[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]$
Instalar dependencias de Python
Ahora es el momento de configurar nuestro proyecto.
Vamos a usar el ejemplo de Audio Similarity Search. Usa un conjunto de archivos de audio disponible públicamente para demostrar cómo puedes usar Milvus para detectar similitudes entre diferentes muestras.
Ve al subdirectorio del proyecto y mira el archivo requirements.txt proporcionado con el código.
(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
Estas son las bibliotecas de Python necesarias para ejecutar el proyecto. Usa pip para instalarlas. Luego, añade Jupyter para que podamos ejecutar el 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)
Iniciar Redis
Ahora, inicia un contenedor Docker de Redis.
docker run --name redis -d -p 6379:6379 redis
Instalar e iniciar Milvus Lite
Finalmente, necesitarás un servidor Milvus. La forma más sencilla de ponerte en marcha con Milvus es Milvus Lite, que se ejecuta en Python. Instala los paquetes 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 ...
Proyecto PyMilvus
Ahora, con un entorno configurado, puedes ejecutar el tutorial.
Iniciar Jupyter
Inicia Jupyter desde tu entorno virtual.
(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)
Esto abrirá la página de Archivos de Jupyter en tu navegador predeterminado.
Navega al directorio solutions/audio/audio_similarity_search.
Abre el notebook audio_similarity_search.
Conectarse a Redis y Milvus
Ya has realizado la configuración inicial, así que desplázate directamente hasta la sección Descripción general del código. El código comienza importando bibliotecas para Redis y Milvus.
En la segunda línea, puedes ver las clases que necesitarás para conectarte a Milvus, crear una Collection, y añadir y recuperar datos de ella.
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)
Luego, el código se conecta a los dos servidores. Ejecuta este bloque. Ahora, es el momento de crear una colección de Milvus para almacenar información sobre cada archivo de 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)
Crear una colección de Milvus
Este paso crea una colección llamada audio_test_collection con dos campos:
- id - un campo de identificación entero
- embedding - un vector de 2048 números de punto flotante para almacenar datos sobre los archivos de audio
Ejecuta este bloque y verás este mensaje:
Dropping existing collection...
Created new collection with name: audio_test_collection
A continuación, añade un índice a tu nueva colección:
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))
Ejecuta este bloque:
Successfully create index in collection:audio_test_collection with param:{'index_type': 'IVF_SQ8', 'metric_type': 'L2', 'params': {'nlist': 16384}}
Almacenar datos de audio
Milvus está listo para almacenar los datos de audio ahora. Vamos a desglosar el siguiente bloque de código y a examinarlo de cerca.
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)
Esta sección importa bibliotecas para procesar los archivos. Luego, crea un objeto AudioTagging a partir de la biblioteca Panns Inference.
Esta es una interfaz de Python para las Large-Scale Pretrained Audio Neural Networks for Audio Pattern Recognition (PANNs).
La clase AudioTagging creará un conjunto de puntos de datos para cada archivo de audio, similar a este:
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,)
A continuación está el código para descargar los archivos, analizarlos e insertar los datos en Milvus, y la información de los archivos en 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))
Este bloque de código lo une todo:
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")
Ejecuta el código:
Checkpoint path: /home/egoebelbecker/panns_data/Cnn14_mAP=0.431.pth
Using CPU.
Starting Insert
Descargando...
Desde: [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]
Inserción completada
Buscar similitudes
Para buscar en la base de datos, necesitas realizar el mismo análisis en los archivos que necesitas comparar. Aquí tienes código para hacerlo con un conjunto seleccionado aleatoriamente de ids de archivos.
```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)
Ejecuta este bloque para seleccionar dos archivos y realizar el análisis. Ahora, es momento de realizar una búsqueda en Milvus. Este código muestra los resultados de búsqueda en reproductores de 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)
A continuación, el programa toma el array embeddings creado anteriormente y lo convierte en una lista. Luego crea nuestros parámetros de búsqueda. Estamos buscando dos sonidos similares y usando nprobe para los criterios. Esto coincide con el tipo de índice que usaste anteriormente.
embeddings_list = embeddings.tolist()
search_params = {"metric_type": "L2", "params": {"nprobe": 16}}
Finalmente, aquí está la búsqueda.
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))
Ejecútalo, y verás los archivos seleccionados aleatoriamente, y dos resultados de búsqueda, con su distancia respecto del original.
Escucha cada archivo, y oirás la coincidencia exacta y su vecino más cercano.
Resumen
En esta publicación, aprendiste cómo crear un entorno de Python para trabajar con Milvus. Después de configurar un servidor y el SDK de PyMilvus, ejecutaste un tutorial de ejemplo del repositorio Milvus Bootcamp. Viste código para crear una colección, indexarla, almacenar datos y realizar una búsqueda básica.
Ahora que has visto lo fácil que es empezar con Milvus, continúa con los proyectos del bootcamp y descubre cómo puedes usar Milvus para mejorar tus proyectos.
Esta publicación fue escrita por Eric Goebelbecker. Eric ha trabajado en los mercados financieros de la ciudad de Nueva York durante 25 años, desarrollando infraestructura para datos de mercado y redes del protocolo de intercambio de información financiera (FIX). Le encanta hablar sobre qué hace que los equipos sean efectivos (¡o no tan efectivos!).
Sigue leyendo
Why I’m Against Claude Code’s Grep-Only Retrieval? It Just Burns Too Many Tokens
Learn how vector-based code retrieval cuts Claude Code token consumption by 40%. Open-source solution with easy MCP integration. Try claude-context today.
Zilliz Cloud Launches in AWS Australia, Expanding Global Reach to Australia and Neighboring Markets
We're thrilled to announce that Zilliz Cloud is now available in the AWS Sydney, Australia region (ap-southeast-2).
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.