Índice com GPU
Este guia descreve as etapas para criar um índice com suporte de GPU no Milvus, o que pode melhorar significativamente o desempenho da pesquisa em cenários de alto rendimento e alta recuperação. Para obter detalhes sobre os tipos de índices de GPU suportados pelo Milvus, consulte Índice de GPU.
Configurar as definições do Milvus para o controlo da memória da GPU
O Milvus usa um pool de memória gráfica global para alocar a memória da GPU.
Ele suporta dois parâmetros initMemSize e maxMemSize no arquivo de configuração do Milvus. O tamanho do pool é inicialmente definido como initMemSize, e será automaticamente expandido para maxMemSize após exceder este limite.
O padrão initMemSize é 1/2 da memória da GPU disponível quando o Milvus inicia, e o padrão maxMemSize é igual a toda a memória da GPU disponível.
Até o Milvus 2.4.1 (incluindo a versão 2.4.1), o Milvus usava um pool de memória GPU unificado. Para versões anteriores à 2.4.1 (incluindo a versão 2.4.1), era recomendado definir ambos os valores como 0.
gpu:
initMemSize: 0 #set the initial memory pool size.
maxMemSize: 0 #maxMemSize sets the maximum memory usage limit. When the memory usage exceed initMemSize, Milvus will attempt to expand the memory pool.
Do Milvus 2.4.1 em diante, o pool de memória da GPU é usado apenas para dados temporários da GPU durante as pesquisas. Por conseguinte, recomenda-se que seja definido para 2048 e 4096.
gpu:
initMemSize: 2048 #set the initial memory pool size.
maxMemSize: 4096 #maxMemSize sets the maximum memory usage limit. When the memory usage exceed initMemSize, Milvus will attempt to expand the memory pool.
Criar um índice
Os exemplos a seguir demonstram como criar índices de GPU de diferentes tipos.
Preparar parâmetros de índice
Ao configurar os parâmetros de índice da GPU, defina index_type, metric_type e params:
index_type(string): O tipo de índice usado para acelerar a pesquisa de vetor. As opções válidas incluem GPU_CAGRA, GPU_IVF_FLAT, GPU_IVF_PQ e GPU_BRUTE_FORCE.
metric_type(string): O tipo de métrica usado para medir a similaridade de vetores. As opções válidas são IP e L2.
params(dict): Os parâmetros de construção específicos do índice. As opções válidas para este parâmetro dependem do tipo de índice.
Aqui estão exemplos de configurações para diferentes tipos de índice:
ÍndiceGPU_CAGRA
index_params = { "metric_type": "L2", "index_type": "GPU_CAGRA", "params": { 'intermediate_graph_degree': 64, 'graph_degree': 32 } }As opções possíveis para params incluem:
intermediate_graph_degree(int): Afeta a recuperação e o tempo de construção ao determinar o grau do gráfico antes da poda. Os valores recomendados são 32 ou 64.
graph_degree(int): Afeta o desempenho da pesquisa e a recuperação ao definir o grau do gráfico após a poda. Normalmente, é metade do grau_do_gráfico_intermediário. Uma diferença maior entre esses dois graus resulta em um tempo de construção mais longo. O seu valor tem de ser inferior ao valor de grau_do_grafo_intermédio.
algoritmo_de_construção(string): Seleciona o algoritmo de geração do grafo antes da poda. Opções possíveis:
IVF_PQ: Oferece maior qualidade mas tempo de construção mais lento.
NN_DESCENT: Oferece uma construção mais rápida com potencialmente menor recall.
cache_dataset_on_device(string, "true" | "false"): Decide se o conjunto de dados original deve ser armazenado em cache na memória da GPU. Definir como "true" aumenta a recuperação ao refinar os resultados da pesquisa, enquanto definir como "false" conserva a memória da GPU.
ÍndiceGPU_IVF_FLAT ou GPU_IVF_PQ
index_params = { "metric_type": "L2", "index_type": "GPU_IVF_FLAT", # Or GPU_IVF_PQ "params": { "nlist": 1024 } }As opções params são idênticas às utilizadas em IVF_FLAT e IVF_PQ.
ÍndiceGPU_BRUTE_FORCE
index_params = { 'index_type': 'GPU_BRUTE_FORCE', 'metric_type': 'L2', 'params': {} }Não são necessárias configurações de parâmetros adicionais.
Construir índice
Depois de configurar os parâmetros do índice em index_params, chame o método create_index() para criar o índice.
# Get an existing collection
collection = Collection("YOUR_COLLECTION_NAME")
collection.create_index(
field_name="vector", # Name of the vector field on which an index is built
index_params=index_params
)
Pesquisar
Depois de criar seu índice GPU, a próxima etapa é preparar os parâmetros de pesquisa antes de realizar uma pesquisa.
Preparar parâmetros de pesquisa
Abaixo estão exemplos de configurações para diferentes tipos de índice:
ÍndiceGPU_BRUTE_FORCE
search_params = { "metric_type": "L2", "params": {} }Não são necessárias configurações de parâmetros adicionais.
ÍndiceGPU_CAGRA
search_params = { "metric_type": "L2", "params": { "itopk_size": 128, "search_width": 4, "min_iterations": 0, "max_iterations": 0, "team_size": 0 } }Os principais parâmetros de pesquisa incluem:
itopk_size: Determina o tamanho dos resultados intermediários mantidos durante a pesquisa. Um valor maior pode melhorar a recuperação às custas do desempenho da pesquisa. Ele deve ser pelo menos igual ao valor final do top-k(limite) e é tipicamente uma potência de 2 (por exemplo, 16, 32, 64, 128).
search_width: Especifica o número de pontos de entrada no gráfico CAGRA durante a pesquisa. O aumento deste valor pode melhorar a recuperação, mas pode afetar o desempenho da pesquisa.
min_iterações / max_iterações: Estes parâmetros controlam o processo de iteração da pesquisa. Por padrão, eles são definidos como 0, e o CAGRA determina automaticamente o número de iterações com base em itopk_size e search_width. O ajuste manual desses valores pode ajudar a equilibrar o desempenho e a precisão.
team_size: Especifica o número de threads CUDA usadas para calcular a distância métrica na GPU. Os valores comuns são uma potência de 2 até 32 (por exemplo, 2, 4, 8, 16, 32). Tem um impacto menor no desempenho da pesquisa. O valor predefinido é 0, em que o Milvus seleciona automaticamente o team_size com base na dimensão do vetor.
ÍndiceGPU_IVF_FLAT ou GPU_IVF_PQ
search_params = { "metric_type": "L2", "params": {"nprobe": 10} }Os parâmetros de pesquisa para esses dois tipos de índice são semelhantes aos usados em IVF_FLAT e IVF_PQ. Para obter mais informações, consulte Realizar uma pesquisa de similaridade de vetor.
Realizar uma pesquisa
Utilize o método search() para executar uma pesquisa de similaridade de vetor no índice GPU.
# Load data into memory
collection.load()
collection.search(
data=[[query_vector]], # Your query vector
anns_field="vector", # Name of the vector field
param=search_params,
limit=100 # Number of the results to return
)
Limites
Ao usar índices de GPU, esteja ciente de certas restrições:
Para GPU_IVF_FLAT, o valor máximo para o limite é 256.
Para GPU_IVF_PQ e GPU_CAGRA, o valor máximo para o limite é 1024.
Embora não exista um limite definido para o limite em GPU_BRUTE_FORCE, recomenda-se que não exceda 4096 para evitar potenciais problemas de desempenho.
Atualmente, os índices GPU não suportam a distância COSINE. Se a distância COSINE for necessária, os dados devem ser normalizados primeiro e, em seguida, a distância do produto interno (IP) pode ser usada como um substituto.
A proteção OOM de carregamento para índices GPU não é totalmente suportada, demasiados dados podem levar a falhas no QueryNode.
Os índices GPU não suportam funções de pesquisa como pesquisa de intervalo e pesquisa de agrupamento.
PERGUNTAS FREQUENTES
Quando é apropriado utilizar um índice GPU?
Um índice de GPU é particularmente benéfico em situações que exigem alta taxa de transferência ou alta recuperação. Por exemplo, ao lidar com grandes lotes, a taxa de transferência da indexação GPU pode superar a da indexação CPU em até 100 vezes. Em cenários com lotes menores, os índices de GPU ainda superam significativamente os índices de CPU em termos de desempenho. Além disso, se houver um requisito de inserção rápida de dados, a incorporação de uma GPU pode acelerar substancialmente o processo de criação de índices.
Em que cenários são mais adequados os índices GPU como CAGRA, GPU_IVF_PQ, GPU_IVF_FLAT e GPU_BRUTE_FORCE?
Os índices CAGRA são ideais para cenários que exigem um melhor desempenho, embora à custa de um maior consumo de memória. Para ambientes em que a conservação de memória é uma prioridade, o índice GPU_IVF_PQ pode ajudar a minimizar os requisitos de armazenamento, embora isso venha com uma maior perda de precisão. O índice GPU_IVF_FLAT serve como uma opção equilibrada, oferecendo um compromisso entre desempenho e uso de memória. Por último, o índice GPU_BRUTE_FORCE foi concebido para operações de pesquisa exaustiva, garantindo uma taxa de recuperação de 1 através da realização de pesquisas transversais.
