Realizar pesquisas de visão com o Milvus e o FiftyOne

O FiftyOne é uma ferramenta de código aberto para criar conjuntos de dados e modelos de visão computacional de alta qualidade. Este guia ajuda-o a integrar as capacidades de pesquisa de semelhança do Milvus no FiftyOne, permitindo-lhe realizar pesquisas de visão nos seus próprios conjuntos de dados.

O FiftyOne fornece uma API para criar coleções Milvus, carregar vetores e executar consultas de similaridade, tanto programaticamente em Python quanto por meio de apontar e clicar no aplicativo. A demonstração nesta página concentra-se na integração programática.

Pré-requisitos

Antes de começar, certifique-se de que tem o seguinte:

• Um servidor Milvus em execução.
• Um ambiente Python com pymilvus e fiftyone instalados.
• Um conjunto de dados de imagens para pesquisar.

Requisitos de instalação

Para este exemplo, vamos utilizar pymilvus e fiftyone. Pode instalá-los executando os seguintes comandos:

python3 -m pip install pymilvus fiftyone torch torchvision

Receita básica

O fluxo de trabalho básico para usar o Milvus para criar um índice de similaridade em seus conjuntos de dados do FiftyOne e usá-lo para consultar seus dados é o seguinte:

1. Carregar um conjunto de dados no FiftyOne
2. Calcule embeddings vetoriais para amostras ou patches no seu conjunto de dados ou selecione um modelo para usar a geração de embeddings.
3. Utilize o método compute_similarity() para gerar um índice de similaridade Milvus para as amostras ou amostras de objectos num conjunto de dados, definindo o parâmetro backend="milvus" e especificando um brain_key à sua escolha.
4. Utilize este índice de semelhança de Milvus para consultar os seus dados com sort_by_similarity().
5. Se pretender, elimine o índice.

Procedimentos

O exemplo abaixo demonstra o fluxo de trabalho acima.

1. Carregue um conjunto de dados no FiftyOne e calcule os embeddings para as amostras

O código a seguir usa o conjunto de imagens de amostra fornecido pelo FiftyOne para demonstrar a integração. Você pode preparar seu próprio conjunto de imagens consultando este artigo.

import fiftyone as fo
import fiftyone.brain as fob
import fiftyone.zoo as foz

# Step 1: Load your data into FiftyOne
dataset = foz.load_zoo_dataset("quickstart")

# Steps 2 and 3: Compute embeddings and create a similarity index
milvus_index = fob.compute_similarity(
    dataset,
    brain_key="milvus_index",
    backend="milvus",
)

2. Efetuar pesquisas de semelhança de visão

Pode agora utilizar o índice de semelhança Milvus para efetuar pesquisas de semelhança de visão no seu conjunto de dados.

# Step 4: Query your data
query = dataset.first().id  # query by sample ID
view = dataset.sort_by_similarity(
    query,
    brain_key="milvus_index",
    k=10,  # limit to 10 most similar samples
)

# Step 5 (optional): Cleanup

# Delete the Milvus collection
milvus_index.cleanup()

# Delete run record from FiftyOne
dataset.delete_brain_run("milvus_index")

3. Eliminar o índice

Se já não precisar do índice de similaridade Milvus, pode eliminá-lo utilizando o seguinte código:

# Step 5: Delete the index
milvus_index.delete()

Utilizar o backend do Milvus

Por predefinição, chamar compute_similarity() ou sort_by_similarity() usará um backend sklearn.

Para utilizar o backend do Milvus, basta definir o parâmetro backend opcional de compute_similarity() para "milvus":

import fiftyone.brain as fob

fob.compute_similarity(..., backend="milvus", ...)

Em alternativa, pode configurar permanentemente o FiftyOne para utilizar o backend Milvus definindo a seguinte variável de ambiente:

export FIFTYONE_BRAIN_DEFAULT_SIMILARITY_BACKEND=milvus

ou definindo o parâmetro default_similarity_backend do seu brain config localizado em ~/.fiftyone/brain_config.json:

{
    "default_similarity_backend": "milvus"
}

Autenticação

Se estiver a utilizar um servidor Milvus personalizado, pode fornecer as suas credenciais de várias formas.

Variáveis de ambiente (recomendado)

A forma recomendada de configurar as suas credenciais Milvus é armazená-las nas variáveis de ambiente apresentadas abaixo, que são automaticamente acedidas pelo FiftyOne sempre que é efectuada uma ligação ao Milvus.

export FIFTYONE_BRAIN_SIMILARITY_MILVUS_URI=XXXXXX
export FIFTYONE_BRAIN_SIMILARITY_MILVUS_USER=XXXXXX
export FIFTYONE_BRAIN_SIMILARITY_MILVUS_PASSWORD=XXXXXX

# also available if necessary
export FIFTYONE_BRAIN_SIMILARITY_MILVUS_SECURE=true
export FIFTYONE_BRAIN_SIMILARITY_MILVUS_TOKEN=XXXXXX
export FIFTYONE_BRAIN_SIMILARITY_MILVUS_DB_NAME=XXXXXX
export FIFTYONE_BRAIN_SIMILARITY_MILVUS_CLIENT_KEY_PATH=XXXXXX
export FIFTYONE_BRAIN_SIMILARITY_MILVUS_CLIENT_PEM_PATH=XXXXXX
export FIFTYONE_BRAIN_SIMILARITY_MILVUS_CA_PEM_PATH=XXXXXX
export FIFTYONE_BRAIN_SIMILARITY_MILVUS_SERVER_PEM_PATH=XXXXXX
export FIFTYONE_BRAIN_SIMILARITY_MILVUS_SERVER_NAME=XXXXXX

Configuração do FiftyOne Brain

Também pode armazenar as suas credenciais na configuração do seu cérebro localizada em ~/.fiftyone/brain_config.json:

{
    "similarity_backends": {
        "milvus": {
            "uri": "XXXXXX",
            "user": "XXXXXX",
            "password": "XXXXXX",

            # also available if necessary
            "secure": true,
            "token": "XXXXXX",
            "db_name": "XXXXXX",
            "client_key_path": "XXXXXX",
            "client_pem_path": "XXXXXX",
            "ca_pem_path": "XXXXXX",
            "server_pem_path": "XXXXXX",
            "server_name": "XXXXXX"
        }
    }
}

Note que este ficheiro não existirá até que o crie.

Argumentos de palavras-chave

Pode fornecer manualmente as suas credenciais Milvus como argumentos de palavras-chave sempre que chamar métodos como compute_similarity() que requerem ligações a Milvus:

import fiftyone.brain as fob

milvus_index = fob.compute_similarity(
    ...
    backend="milvus",
    brain_key="milvus_index",
    uri="XXXXXX",
    user="XXXXXX",
    password="XXXXXX",

    # also available if necessary
    secure=True,
    token="XXXXXX",
    db_name="XXXXXX",
    client_key_path="XXXXXX",
    client_pem_path="XXXXXX",
    ca_pem_path="XXXXXX",
    server_pem_path="XXXXXX",
    server_name="XXXXXX",
)

Note que, ao utilizar esta estratégia, tem de fornecer manualmente as credenciais quando carregar um índice mais tarde através de load_brain_results():

milvus_index = dataset.load_brain_results(
    "milvus_index",
    uri="XXXXXX",
    user="XXXXXX",
    password="XXXXXX",

    # also available if necessary
    secure=True,
    token="XXXXXX",
    db_name="XXXXXX",
    client_key_path="XXXXXX",
    client_pem_path="XXXXXX",
    ca_pem_path="XXXXXX",
    server_pem_path="XXXXXX",
    server_name="XXXXXX",
)

Parâmetros de configuração do Milvus

O backend do Milvus suporta uma variedade de parâmetros de consulta que podem ser utilizados para personalizar as suas consultas de similaridade. Esses parâmetros incluem:

• collection_name(None): o nome da coleção Milvus a utilizar ou a criar. Se não for fornecido nenhum, será criada uma nova coleção

• metric ("dotproduct"): a métrica de distância de incorporação a utilizar ao criar um novo índice. Os valores suportados são ("dotproduct", "euclidean")

• consistency_level ("Session"): o nível de consistência a utilizar. Os valores suportados são ("Strong", "Session", "Bounded", "Eventually")

Para obter informações pormenorizadas sobre estes parâmetros, consulte a documentação sobre a autenticação Milvus e a documentação sobre os níveis de consistência Milvus.

Pode especificar estes parâmetros através de qualquer uma das estratégias descritas na secção anterior. Aqui está um exemplo de uma configuração de cérebro que inclui todos os parâmetros disponíveis:

{
    "similarity_backends": {
        "milvus": {
            "collection_name": "your_collection",
            "metric": "dotproduct",
            "consistency_level": "Strong"
        }
    }
}

No entanto, normalmente estes parâmetros são passados diretamente para compute_similarity() para configurar um novo índice específico:

milvus_index = fob.compute_similarity(
    ...
    backend="milvus",
    brain_key="milvus_index",
    collection_name="your_collection",
    metric="dotproduct",
    consistency_level="Strong",
)

Gerir execuções de cérebros

O FiftyOne fornece uma variedade de métodos que pode utilizar para gerir as execuções do cérebro.

Por exemplo, é possível chamar list_brain_runs() para ver as chaves de cérebro disponíveis em um conjunto de dados:

import fiftyone.brain as fob

# List all brain runs
dataset.list_brain_runs()

# Only list similarity runs
dataset.list_brain_runs(type=fob.Similarity)

# Only list specific similarity runs
dataset.list_brain_runs(
    type=fob.Similarity,
    patches_field="ground_truth",
    supports_prompts=True,
)

Ou, pode usar get_brain_info() para obter informações sobre a configuração de um brain run:

info = dataset.get_brain_info(brain_key)
print(info)

Utilize load_brain_results() para carregar a instância SimilarityIndex para um brain run.

Pode utilizar rename_brain_run() para mudar o nome da chave do cérebro associada a uma execução de resultados de similaridade existente:

dataset.rename_brain_run(brain_key, new_brain_key)

Finalmente, pode utilizar delete_brain_run() para eliminar uma execução do cérebro:

dataset.delete_brain_run(brain_key)

# Delete the Milvus collection
milvus_index = dataset.load_brain_results(brain_key)
milvus_index.cleanup()

Para um fluxo de trabalho de pesquisa vetorial comum num conjunto de dados FiftyOne utilizando o backend Milvus, consulte Exemplos aqui.