Começando com o PyMilvus
Milvus, um banco de dados vetorial de código aberto, combinado com PyMilvus - seu SDK para Python, é uma ferramenta poderosa para lidar com grandes conjuntos de dados e realizar cálculos e buscas avançadas.
Este tutorial irá guiá-lo na instalação e configuração de um ambiente de desenvolvimento para usar Milvus e PyMilvus. Em seguida, você percorrerá um exemplo de código para analisar arquivos de áudio, armazenar seus dados no Milvus e depois usá-lo para comparar amostras de áudio em busca de semelhanças. Vamos começar.
O que é Milvus?
Milvus é um banco de dados vetorial de código aberto que lida com busca e análise de similaridade vetorial em escala de trilhões. É uma plataforma poderosa e eficiente para gerenciar e pesquisar dados não estruturados por meio de vetores de embedding, uma capacidade cada vez mais importante em aprendizado de máquina, visão computacional, sistemas de recomendação e outros campos de inteligência artificial (IA).
Em sua essência, o Milvus aproveita o conceito de embeddings, em que pontos de dados são representados como vetores de alta dimensão. Esses vetores podem capturar a similaridade entre pontos de dados com base em suas características semânticas ou visuais. O Milvus permite o armazenamento, a indexação e a recuperação desses vetores, possibilitando que os usuários realizem buscas rápidas de similaridade em enormes conjuntos de dados.
Com sua arquitetura distribuída e suporte para aceleração por GPU, o Milvus pode processar eficientemente grandes volumes de dados vetoriais e fornecer resultados de busca em tempo real. Além disso, oferece uma variedade de algoritmos de indexação otimizados para diferentes casos de uso, incluindo algoritmos de busca aproximada do vizinho mais próximo (ANN), para equilibrar precisão e eficiência.
O Milvus oferece suporte a várias linguagens de programação e fornece APIs fáceis de usar, tornando-o acessível a desenvolvedores e pesquisadores. Além disso, integra-se bem a frameworks populares de aprendizado de máquina e ferramentas de processamento de dados, permitindo integração perfeita aos fluxos de trabalho existentes.
O que é PyMilvus?
PyMilvus é o SDK Python para Milvus. Ele foi projetado para permitir que desenvolvedores Python interajam com o Milvus de forma fácil e eficiente, facilitando tarefas como gerenciar dados, realizar buscas de similaridade vetorial, construir índices e muito mais.
Com PyMilvus, os desenvolvedores aproveitam todo o poder do Milvus em suas aplicações Python sem precisar se preocupar com os detalhes das operações subjacentes do banco de dados. Ele abstrai muitas das complexidades de trabalhar com o Milvus, fornecendo uma API simples e fácil de usar que se integra perfeitamente aos fluxos de trabalho Python existentes.
Configuração para o tutorial
Os exemplos de linha de comando nesta publicação serão do Linux, mas devem ser facilmente adaptáveis ao macOS ou ao Windows com o Windows Subsystem for Linux (WSL). Você precisará de um sistema com Docker ou Docker Desktop, Python 3.10+ e git.
Repositório Milvus bootcamp
Vamos usar código do repositório Milvus Bootcamp no Github para este tutorial. Comece clonando o repositório para seu 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.
Ambiente virtual Python
Em seguida, crie um ambiente virtual para executar seu código. Você pode colocá-lo no diretório onde clonou o repositório bootcamp. Ative o ambiente depois de criá-lo.
[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]$
Instale as dependências Python
Agora é hora de configurar nosso projeto.
Vamos usar o exemplo de Busca por Similaridade de Áudio. Ele usa um conjunto de arquivos de áudio disponível publicamente para demonstrar como você pode usar o Milvus para detectar semelhanças entre diferentes amostras.
Vá para o subdiretório do projeto e veja o arquivo requirements.txt fornecido com o 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 são as bibliotecas Python necessárias para executar o projeto. Use pip para instalá-las. Em seguida, adicione o Jupyter para que possamos executar o notebook.
(venv) [egoebelbecker@ares audio_similarity_search]$ pip install -r requirements.txt
(Muita saída)
(venv) [egoebelbecker@ares audio_similarity_search]$ pip install jupyter
(Mais saída)
Inicie o Redis
Agora, inicie um contêiner Docker do Redis.
docker run --name redis -d -p 6379:6379 redis
Instale e inicie o Milvus Lite
Por fim, você precisará de um servidor Milvus. A maneira mais fácil de começar a usar o Milvus é com o Milvus Lite, que é executado em Python. Instale os pacotes milvus.
(venv) [egoebelbecker@ares audio_similarity_search]$ pip install milvus
(Muita saída)
(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 ...
Projeto PyMilvus
Agora, com um ambiente configurado, você pode executar o tutorial.
Inicie o Jupyter
Inicie o Jupyter a partir do seu ambiente 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
(Mais saída)
Isso abrirá a página de Arquivos do Jupyter no seu navegador padrão.
Navegue até o diretório solutions/audio/audio_similarity_search.
Abra o notebook audio_similarity_search.
Conecte-se ao Redis e ao Milvus
Você já fez a configuração inicial, então role diretamente para a seção Visão geral do código. O código começa importando bibliotecas para Redis e Milvus.
Na segunda linha, você pode ver as classes necessárias para se conectar ao Milvus, criar uma Collection, e adicionar e recuperar dados dela.
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)
Em seguida, o código se conecta aos dois servidores. Execute este bloco. Agora, é hora de criar uma coleção Milvus para armazenar informações sobre cada arquivo de áudio.
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)
Criar uma coleção Milvus
Esta etapa cria uma coleção chamada audio_test_collection com dois campos:
- id - um campo de identificação inteiro
- embedding - um vetor de 2048 números de ponto flutuante para armazenar dados sobre os arquivos de áudio
Execute este bloco e você verá esta mensagem:
Dropping existing collection...
Created new collection with name: audio_test_collection
Em seguida, adicione um índice à sua nova coleção:
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))
Execute este bloco:
Successfully create index in collection:audio_test_collection with param:{'index_type': 'IVF_SQ8', 'metric_type': 'L2', 'params': {'nlist': 16384}}
Armazenar dados de áudio
O Milvus está pronto para armazenar os dados de áudio agora. Vamos dividir o próximo bloco de código e analisá-lo atentamente.
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 seção importa bibliotecas para processar os arquivos. Em seguida, ela cria um objeto AudioTagging a partir da biblioteca Panns Inference.
Esta é uma interface Python para as Large-Scale Pretrained Audio Neural Networks for Audio Pattern Recognition (PANNs).
A classe AudioTagging criará um conjunto de pontos de dados para cada arquivo de áudio, semelhante 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 seguir está o código para baixar os arquivos, analisá-los e inserir os dados no Milvus, e as informações dos arquivos no 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 bloco de código junta tudo:
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")
Execute o código:
Checkpoint path: /home/egoebelbecker/panns_data/Cnn14_mAP=0.431.pth
Using CPU.
Starting Insert
Baixando...
De: [https://drive.google.com/uc?id=1bKu21JWBfcZBuEuzFEvPoAX6PmRrgnUp](https://drive.google.com/uc?id=1bKu21JWBfcZBuEuzFEvPoAX6PmRrgnUp)
Para: /home/egoebelbecker/src/bootcamp/solutions/audio/audio_similarity_search/example_audio.zip
100%|█████████████████████████████████████████████████████████████████████████████████████████| 474k/474k [00:00<00:00, 8.87MB/s]
Inserção concluída
Buscar semelhanças
Para pesquisar no banco de dados, você precisa realizar a mesma análise nos arquivos que precisa comparar. Aqui está o código para fazer isso em um conjunto selecionado aleatoriamente de ids de arquivos.
```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)
Execute este bloco para selecionar dois arquivos e executar a análise. Agora, é hora de realizar uma busca no Milvus. Este código exibe os resultados da busca em players de áudio:
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)
Em seguida, o programa pega o array embeddings criado acima e o converte em uma lista. Depois, ele cria nossos parâmetros de busca. Estamos procurando dois sons semelhantes e usando nprobe para os critérios. Isso corresponde ao tipo de índice que você usou acima.
embeddings_list = embeddings.tolist()
search_params = {"metric_type": "L2", "params": {"nprobe": 16}}
Finalmente, aqui está a busca.
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))
Execute-o, e você verá os arquivos selecionados aleatoriamente e dois resultados de busca, com sua distância em relação ao original.
Ouça cada arquivo, e você ouvirá a correspondência exata e seu vizinho mais próximo.
Resumo
Neste post, você aprendeu como criar um ambiente Python para trabalhar com o Milvus. Depois de configurar um servidor e o SDK PyMilvus, você executou um tutorial de exemplo do repositório Milvus Bootcamp. Você viu código para criar uma coleção, indexá-la, armazenar dados e realizar uma busca básica.
Agora que você viu como é fácil começar com o Milvus, continue com os projetos do bootcamp e veja como você pode usar o Milvus para aprimorar seus projetos.
Este post foi escrito por Eric Goebelbecker. Eric trabalhou nos mercados financeiros em Nova York por 25 anos, desenvolvendo infraestrutura para dados de mercado e redes de protocolo de troca de informações financeiras (FIX). Ele adora falar sobre o que torna as equipes eficazes (ou não tão eficazes!).
Continue lendo
Zilliz Cloud Now Available in AWS Europe (Ireland)
Zilliz Cloud launches in AWS eu-west-1 (Ireland) — bringing low-latency vector search, EU data residency, and full GDPR-ready infrastructure to European AI teams. Now live across 30 regions on five cloud providers.
Creating Collections in Zilliz Cloud Just Got Way Easier
We've enhanced the entire collection creation experience to bring advanced capabilities directly into the interface, making it faster and easier to build production-ready schemas without switching tools.
Demystifying the Milvus Sizing Tool
Explore how to use the Sizing Tool to select the optimal configuration for your Milvus deployment.