Habilitar e usar a extensão DiskANN

O DiskANN é um algoritmo de pesquisa de vizinho aproximado escalonável para busca em vetores eficiente em qualquer escala. Ele oferece elevada capacidade de recuperação, alta taxa de consultas por segundo e baixa latência de consulta, mesmo para conjuntos de dados de bilhões de pontos. Essas características o tornam uma ferramenta poderosa para lidar com grandes volumes de dados.

Para saber mais sobre DiskANN, consulte DiskANN: Busca Vetorial para Pesquisa e Recomendação em Escala de Web.

A pg_diskann extensão adiciona suporte ao uso do DiskANN para indexação e pesquisa de vetores eficientes.

Habilitar pg_diskann

Para usar a extensão pg_diskann na instância de servidor flexível do Banco de Dados do Azure para PostgreSQL, você precisa permitir a extensão no nível da instância. Em seguida, você precisa criar a extensão em cada banco de dados no qual deseja usar a funcionalidade fornecida pela extensão.

Como pg_diskann tem uma dependência da extensão vector, você deve permitir e criar a extensão vector no mesmo banco de dados e executar o seguinte comando:

CREATE EXTENSION IF NOT EXISTS pg_diskann;

Ou você pode ignorar a permissão explícita e a criação da vector extensão e, em vez disso, executar o comando anterior acrescentando a cláusula CASCADE. PostgreSQL executa implicitamente a cláusula CREATE EXTENSION na extensão da qual depende. Para tal, execute o seguinte comando:

CREATE EXTENSION IF NOT EXISTS pg_diskann CASCADE;

Para remover a extensão do banco de dados ao qual você está conectado no momento, execute o seguinte comando:

DROP EXTENSION IF EXISTS pg_diskann;

Usar o método de acesso ao índice Diskann

Depois que a extensão for instalada, você poderá criar um índice diskann em uma coluna de tabela que contenha dados de vetor. Por exemplo, para criar um índice na coluna embedding da tabela demo, use o seguinte comando:

CREATE TABLE demo (
 id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
 embedding public.vector(3)
 -- other columns
);

-- insert dummy data
INSERT INTO demo (embedding) VALUES
('[1.0, 2.0, 3.0]'),
('[4.0, 5.0, 6.0]'),
('[7.0, 8.0, 9.0]');

-- create a diskann index by using Cosine distance operator
CREATE INDEX demo_embedding_diskann_idx ON demo USING diskann (embedding vector_cosine_ops)

Depois que o índice for criado, você poderá executar consultas para localizar os vizinhos mais próximos.

A consulta a seguir localiza os cinco vizinhos mais próximos ao vetor [2.0, 3.0, 4.0]:

SELECT id, embedding
FROM demo
ORDER BY embedding <=> '[2.0, 3.0, 4.0]'
LIMIT 5;

O Postgres decide automaticamente quando usar o índice DiskANN. Se optar por não usar o índice em um cenário no qual você deseja que ele o use, execute o seguinte comando:

-- Explicit Transcation block to force use for DiskANN index.

BEGIN;
SET LOCAL enable_seqscan TO OFF;
-- Similarity search queries
COMMIT;

Dimensionar com eficiência com Quantization (versão prévia)

DiskANN usa pq (quantização de produto) para reduzir drasticamente o volume de memória dos vetores. Ao contrário de outras técnicas de quantização, o algoritmo PQ pode compactar vetores de forma mais eficaz, melhorando significativamente o desempenho.  DiskANN usando PQ pode manter mais dados na memória, reduzindo a necessidade de acessar o armazenamento mais lento, bem como usando menos computação ao comparar vetores compactados. Isso resulta em melhor desempenho e economia significativa de custos ao trabalhar com quantidades maiores de dados (> 1 milhão de linhas).

Para reduzir o tamanho do índice e ajustar mais dados na memória, você pode usar PQ:

CREATE INDEX demo_embedding_diskann_idx ON demo USING diskann(embedding vector_cosine_ops) 
WITH(
    product_quantized=true
    );    

Aprimorar a exatidão ao usar o PQ com a reclassificação de vetor

A reclassificação com vetores completos é uma técnica usada em sistemas de pesquisa ANN (vizinho mais próximo) aproximado, como DiskANN com PQ (compartimentalização de produto) para aprimorar a exatidão do resultado reordenando os N principais candidatos recuperados usando os vetores descompactados originais (exatidão total). Essa técnica de reclassificação baseia-se puramente em métricas exatas de similaridade vetorial (por exemplo, similaridade de cosseno ou distância euclidiana). Essa técnica não é a mesma que a reclassificação usando um modelo de classificação.

Para equilibrar velocidade e exatidão na pesquisa de similaridade vetorial, uma estratégia de reclassificação em duas etapas pode ser implementada ao consultar com DiskANN e a compartimentalização de produto a fim de aprimorar a exatidão.

1. Pesquisa Aproximada Inicial: a consulta interna usa DiskANN para recuperar os 50 vizinhos mais próximos aproximados com base na distância de cosseno entre as inserções armazenadas e o vetor de consulta. Esta etapa é rápida e eficiente, aproveitando os recursos de indexação do DiskANN.

2. Reclassificado preciso: a consulta externa reordena esses 50 resultados pela distância computada real e retorna as 10 correspondências mais relevantes:

Aqui está um exemplo de reclassificação usando esta abordagem de duas etapas:

SELECT id
FROM (
    SELECT id, embedding <=> %s::vector AS distance
    FROM demo
    ORDER BY embedding <=> %s::vector asc
    LIMIT 50
) AS t
ORDER BY t.distance
LIMIT 10;

Essa abordagem equilibra a velocidade (por meio da pesquisa aproximada) e a exatidão (por meio da reclassificação de vetor completo), garantindo resultados de alta qualidade sem verificar todo o conjunto de dados.

Suporte para inserções de alta dimensão

Os aplicativos avançados de IA generativa geralmente dependem de modelos de incorporação de alta dimensão, como text-embedding-3-large, para obter uma precisão superior. No entanto, métodos de indexação tradicionais como HNSW no pgvector são limitados a vetores com até 2.000 dimensões, o que restringe o uso desses modelos avançados.

A partir de pg_diskann v0.6 e superior, o DiskANN agora dá suporte à indexação de vetores com até 16.000 dimensões, expandindo significativamente o escopo para cargas de trabalho de IA de alta precisão.

Configurações recomendadas:

• product_quantized: definido como true
• pq_param_num_chunks: Configure para um terço da dimensão de incorporação para um desempenho ideal.
• pq_param_training_samples: determinado automaticamente com base no tamanho da tabela, a menos que seja definido explicitamente.

Esse aprimoramento permite uma pesquisa escalonável e eficiente em grandes conjuntos de dados de vetor, mantendo alta precisão e recall.

Acelerar a construção do índice

Recomendamos algumas maneiras de melhorar o tempo de construção do índice.

Usando mais memória

Para acelerar a criação do índice, você pode aumentar a memória alocada na sua instância Postgres para a construção do índice. O uso da memória pode ser especificado por meio do maintenance_work_mem parâmetro.

-- Set the parameters
SET maintenance_work_mem = '8GB'; -- Depending on your resources

Em seguida, CREATE INDEX o comando usa a memória de trabalho especificada, dependendo dos recursos disponíveis, para criar o índice.

CREATE INDEX demo_embedding_diskann_idx ON demo USING diskann (embedding vector_cosine_ops)

Usando paralelização

Para acelerar a criação do índice, você pode usar trabalhadores paralelos. Ao criar a tabela, o número de trabalhadores pode ser especificado por meio do parallel_workers parâmetro de armazenamento da CREATE TABLE instrução. E isso pode ser ajustado posteriormente usando a cláusula SET da instrução ALTER TABLE.

CREATE TABLE demo (
	id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
	embedding public.vector(3)
) WITH (parallel_workers = 4);
ALTER TABLE demo SET (parallel_workers = 8);

Em seguida, CREATE INDEX o comando usa o número especificado de trabalhos paralelos, dependendo dos recursos disponíveis, para criar o índice.

CREATE INDEX demo_embedding_diskann_idx ON demo USING diskann (embedding vector_cosine_ops)

Se você quiser criar o índice usando trabalhos paralelos, também precisará definir max_parallel_workers, max_worker_processese max_parallel_maintenance_workers parâmetros adequadamente. Para obter mais informações sobre esses parâmetros, consulte parâmetros que controlam usos de recursos e comportamento assíncrono.

Você pode definir esses parâmetros em diferentes níveis de granularidade. Por exemplo, para defini-las no nível da sessão, você pode executar as seguintes instruções:

-- Set the parameters
SET max_parallel_workers = 8;
SET max_worker_processes = 8; -- Note: Requires server restart
SET max_parallel_maintenance_workers = 4;

Para saber mais sobre outras opções para configurar esses parâmetros no servidor flexível do Banco de Dados do Azure para PostgreSQL, consulte Configurar parâmetros de servidor.

Se a configuração desses parâmetros e os recursos disponíveis no servidor não permitirem a inicialização dos trabalhos paralelos, o PostgreSQL retornará automaticamente para criar o índice no modo não paralelo.

Parâmetros de configuração

Ao criar um diskann índice, você pode especificar vários parâmetros para controlar seu comportamento.

Parâmetros de índice

• max_neighbors: número máximo de arestas por nó no gráfico (o padrão é 32). Um valor mais alto pode melhorar o recall até um determinado ponto.
• l_value_ib: tamanho da lista de pesquisa durante a criação do índice (o padrão é 100). Um valor mais alto torna a compilação mais lenta, mas isso melhoraria a qualidade do índice.
• product_quantized: habilita a compartimentalização de produto para uma pesquisa mais eficiente (o padrão é falso).
• pq_param_num_chunks: número de partes para a compartimentalização do produto (o padrão é 0). 0 significa que ele é determinado automaticamente, com base nas dimensões de inserção. É recomendável usar 1/3 das dimensões de inserção originais.
• pq_param_training_samples: número de vetores para treinar a tabela dinâmica PQ (o padrão é 0). 0 significa que ele é determinado automaticamente, com base no tamanho da tabela.

CREATE INDEX demo_embedding_diskann_custom_idx ON demo USING diskann (embedding vector_cosine_ops)
WITH (
 max_neighbors = 48,
 l_value_ib = 100,
 product_quantized=true, 
 pq_param_num_chunks = 0,
 pq_param_training_samples = 0
 );

Parâmetros de extensão

• diskann.iterative_search: controla o comportamento da pesquisa.

  Configurações para diskann.iterative_search:

  • relaxed_order (padrão): permite que o diskann pesquise iterativamente o grafo em lotes de diskann.l_value_is, até que o número desejado de tuplas, possivelmente limitado por LIMIT cláusula, seja gerado. Pode fazer com que os resultados fiquem fora de ordem.

  • strict_order: semelhante a relaxed_order, permite que o diskann pesquise iterativamente o grafo até que o número desejado de tuplas seja gerado. No entanto, garante que os resultados sejam retornados em ordem estrita classificada pela distância.

  • off: usa a funcionalidade de pesquisa não iterativa, o que significa que ele tenta buscar tuplas diskann.l_value_is em uma etapa. A pesquisa nãoiterativa só pode retornar um máximo de diskann.l_value_is vetores para uma consulta, independentemente da LIMIT cláusula ou do número de tuplas que correspondem à consulta.

  Para alterar o comportamento de pesquisa para strict_order, para todas as consultas executadas na sessão atual, execute a seguinte instrução:

  SET diskann.iterative_search TO 'strict_order';
  

  Para alterá-lo para que ele afete apenas todas as consultas executadas na transação atual, execute a seguinte instrução:

  BEGIN;
  SET LOCAL diskann.iterative_search TO 'strict_order';
  -- All your queries
  COMMIT;
  

• diskann.l_value_is: valor L para verificação de índice (o padrão é 100). Aumentar o valor melhora o recall, mas pode diminuir a velocidade das consultas.

  Para alterar o valor L da verificação de índice para 20, para todas as consultas executadas na sessão atual, execute a seguinte instrução:

  SET diskann.l_value_is TO 20;
  

  Para alterá-lo para que ele afete apenas todas as consultas executadas na transação atual, execute a seguinte instrução:

  BEGIN;
  SET LOCAL diskann.l_value_is TO 20;
  -- All your queries
  COMMIT;
  

Configuração recomendada de parâmetros

Progresso na criação de índice e reindexação

Com o PostgreSQL 12 e mais recente, você pode usar pg_stat_progress_create_index para verificar o progresso das operações CREATE INDEX ou REINDEX.

SELECT phase, round(100.0 * blocks_done / nullif(blocks_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;

Para saber mais sobre as possíveis fases pelas quais uma operação CREATE INDEX ou REINDEX passa, consulte as fases CREATE INDEX.

Seleção da função de acesso ao índice

O tipo de vetor permite que você execute três tipos de pesquisas nos vetores armazenados. Você precisa selecionar a função de acesso correta para o índice, para que o banco de dados possa considerar seu índice ao executar suas consultas.

pg_diskann dá suporte aos seguintes operadores de distância

• vector_l2_ops: <-> Distância euclidiana
• vector_cosine_ops: <=> distância Cosseno
• vector_ip_ops: <#> Produto Interno

Resolução de problemas

Erro: assertion left == right failed left: 40 right: 0:

• A Versão DiskANN GA, v0.6.x, apresenta alterações significativas no formato de metadados de índice. Os índices criados com a versão 0.5.x não são compatíveis com as operações de inserção da versão 0.6.x. A tentativa de inserir em uma tabela com um índice desatualizado resultará em um erro, mesmo que o índice pareça válido.

• Ao encontrar esse erro, você pode resolver:

  • Opção 1: Executando a instrução REINDEX ou REDINDEX CONCURRENTLY no índice.

  • Opção 2: Recompilar o índice

    DROP INDEX your_index_name;
    CREATE INDEX your_index_name ON your_table USING diskann(your_vector_column vector_cosine_ops);
    
    

Erro: diskann index needs to be upgraded to version 2...:

• Ao encontrar esse erro, você pode resolver:

  • Opção 1: Executando a instrução REINDEX ou REDINDEX CONCURRENTLY no índice.

  • Opção 2: Como REINDEX pode levar muito tempo, a extensão também fornece uma função definida pelo usuário chamada upgrade_diskann_index(), que atualiza seu índice mais rapidamente, quando possível.

    Para atualizar o índice, execute a seguinte instrução:

    SELECT upgrade_diskann_index('demo_embedding_diskann_custom_idx');
    

    Para atualizar todos os índices de diskann no banco de dados para a versão atual, execute a seguinte instrução:

    SELECT upgrade_diskann_index(pg_class.oid)
    FROM pg_class
    JOIN pg_am ON (pg_class.relam = pg_am.oid)
    WHERE pg_am.amname = 'diskann';
    

Conteúdo relacionado

• Habilite e use o pgvector no servidor flexível do Banco de Dados do Azure para PostgreSQL.
• Gerenciar extensões do PostgreSQL.