Padrões de pesquisa vetorial e de texto completo híbrida

Esta página descreve como realizar pesquisas híbridas de texto completo e vetoriais no Spanner. A pesquisa híbrida combina a precisão da correspondência de palavras-chave (pesquisa de texto completo, FTS) com a capacidade de recall da correspondência semântica (pesquisa vetorial) para produzir resultados de pesquisa altamente relevantes.

O Spanner oferece suporte aos seguintes padrões de pesquisa híbrida, que são divididos em três categorias principais:

Categoria Descrição Objetivo principal
Fusion A Fusion recupera e classifica documentos de forma independente usando a pesquisa por palavras-chave e vetorial e, em seguida, combina (funde) os resultados. Alcance o máximo de recall e relevância combinando vários indicadores de pontuação.
Filtered As palavras-chave filtram ou refinam o espaço de pesquisa. Garanta que a correspondência de palavras-chave seja um requisito ao aproveitar a relevância semântica.
ML reranking Um modelo de machine learning refina um conjunto inicial de candidatos para uma classificação final mais precisa. Alcance a maior precisão possível para um pequeno conjunto final de resultados.

A pesquisa de fusão envolve a execução independente da FTS e da pesquisa vetorial no mesmo corpus de dados. Em seguida, ela mescla os resultados para criar uma lista classificada única, unificada e altamente relevante.

Embora seja possível executar consultas independentes no lado do cliente, a pesquisa híbrida no Spanner oferece as seguintes vantagens:

  • Simplifica a lógica do aplicativo gerenciando solicitações paralelas e mesclagem de resultados no servidor.
  • Evita a transferência de conjuntos de resultados intermediários potencialmente grandes para o cliente.

É possível usar o SQL para criar métodos de fusão no Spanner. Esta seção fornece exemplos de fusão de classificação recíproca e fusão de pontuação relativa. No entanto, recomendamos avaliar diferentes estratégias de fusão para determinar qual delas melhor atende aos requisitos do seu aplicativo.

Fusão baseada em classificação

Use a fusão baseada em classificação quando as pontuações de relevância de diferentes métodos de recuperação (como pontuações de FTS e distâncias vetoriais) forem difíceis de comparar ou normalizar porque são medidas em espaços diferentes. Esse método usa a posição de classificação de cada documento de cada recuperador para gerar uma pontuação e classificação finais.

A fusão de classificação recíproca (RRF) é uma função de fusão baseada em classificação. A pontuação de RRF para um documento é a soma dos recíprocos das classificações de vários recuperadores, calculada da seguinte maneira:

\[ score\ (d\epsilon D)\ =\ \sum\limits_{r\epsilon R}^{}(1\ /\ (\ 𝑘\ +\ ran{k}_{r}\ (𝑑)\ )\ )\ \]

Em que:

  • d é o documento.
  • R é o conjunto de recuperadores (FTS e pesquisa vetorial).
  • k é uma constante (geralmente definida como 60) usada para moderar a influência de documentos com classificação muito alta.
  • w é a classificação do documento do recuperador r.

Implementar a RRF em uma consulta do Spanner

As métricas vetoriais (como APPROX_DOT_PRODUCT) e as pontuações de pesquisa de texto (como SCORE_NGRAMS) operam em escalas incompatíveis. Para resolver isso, o exemplo a seguir implementa a RRF para normalizar os dados com base na posição de classificação, em vez de pontuações brutas.

A consulta usa UNNEST(ARRAY(...) WITH OFFSET) para atribuir uma classificação aos 100 principais candidatos de cada método. Em seguida, ela calcula uma pontuação padronizada usando o inverso dessas classificações e agrega os resultados para retornar as cinco principais correspondências.

SELECT SUM(1 / (60 + rank)) AS rrf_score, key
FROM (
  (
    SELECT rank, x AS key
    FROM UNNEST(ARRAY(
      SELECT key
      FROM hybrid_search
      WHERE embedding IS NOT NULL
      ORDER BY APPROX_DOT_PRODUCT(@vector, embedding,
        OPTIONS => JSON '{"num_leaves_to_search": 50}') DESC
      LIMIT 100)) AS x WITH OFFSET AS rank
  )
  UNION ALL
  (
    SELECT rank, x AS key
    FROM UNNEST(ARRAY(
      SELECT key
      FROM hybrid_search
      WHERE SEARCH_NGRAMS(text_tokens_ngrams, 'foo')
      ORDER BY SCORE_NGRAMS(text_tokens_ngrams, 'foo') DESC
      LIMIT 100)) AS x WITH OFFSET AS rank
  )
)
GROUP BY key
ORDER BY rrf_score DESC
LIMIT 5;

Fusão baseada em pontuação

A fusão baseada em pontuação é eficaz quando as pontuações de relevância de diferentes métodos são comparáveis ou podem ser normalizadas, o que pode permitir uma classificação mais precisa que incorpora o peso de relevância real de cada método.

A fusão de pontuação relativa (RSF) é um método baseado em pontuação que normaliza as pontuações de diferentes métodos em relação às pontuações mais altas e mais baixas em cada método, normalmente usando as funções MIN() e MAX(). A pontuação de RSF de um documento recuperado por um conjunto de recuperadores é calculada da seguinte maneira:

\[ score(d\epsilon D)\ =\ \sum\limits_{r\epsilon R}^{}({w}_{r}*(scor{e}_{r}(d)\ -\ mi{n}_{r})\ /\ (ma{x}_{r\ }-mi{n}_{r})\ ) \]

Em que:

  • d é o documento.
  • R é o conjunto de recuperadores (FTS e pesquisa vetorial).
  • w é o peso atribuído a um recuperador específico.

Implementar a RSF em uma consulta do Spanner

Para implementar a RSF, é necessário normalizar as pontuações do vetor e da FTS para uma escala comum. O exemplo a seguir calcula as pontuações mínima e máxima em cláusulas WITH separadas para derivar os fatores de normalização. Em seguida, ele combina os resultados usando um FULL OUTER JOIN, somando as pontuações normalizadas da pesquisa de vizinho aproximado mais próximo (ANN, na sigla em inglês) (convertida de cosine_distance) e da FTS.

WITH ann AS (
  SELECT key, APPROX_COSINE_DISTANCE(@vector, embedding,
    OPTIONS => JSON '{"num_leaves_to_search": 50}') AS cosine_distance,
  FROM hybrid_search
  WHERE embedding IS NOT NULL
  ORDER BY cosine_distance
  LIMIT 100
),
fts AS (
  SELECT key, SCORE_NGRAMS(text_tokens_ngrams, 'Green') AS score,
  FROM hybrid_search
    WHERE SEARCH_NGRAMS(text_tokens_ngrams, 'Green')
    ORDER BY score DESC
    LIMIT 100
),
ann_min AS (
  SELECT MIN(1 - cosine_distance) AS min
  FROM ann
),
ann_max AS (
  SELECT MAX(1 - cosine_distance) AS max
  FROM ann
),
fts_min AS (
  SELECT MIN(score) AS min
  FROM fts
),
fts_max AS (
  SELECT MAX(score) AS max
  FROM fts
)
SELECT IFNULL(ann.key, fts.key),
       IFNULL(((1 - ann.cosine_distance) - ann_min.min) /
               (ann_max.max - ann_min.min), 0) +
       IFNULL((fts.score - fts_min.min) /
               (fts_max.max - fts_min.min), 0) AS score
FROM ann
FULL OUTER JOIN fts
ON ann.key = fts.key
CROSS JOIN ann_min
CROSS JOIN ann_max
CROSS JOIN fts_min
CROSS JOIN fts_max
ORDER BY score DESC
LIMIT 5;

As pesquisas filtradas usam a FTS para criar um filtro que reduz o conjunto de documentos considerados para uma pesquisa vetorial de vizinho k-mais perto (KNN, na sigla em inglês). Opcionalmente, é possível usar uma pré-classificação para limitar o tamanho do conjunto de resultados.

A pesquisa de exemplo nesta seção segue estas etapas para restringir o espaço de pesquisa vetorial ao subconjunto de dados que corresponde às palavras-chave:

  • Usa SEARCH (text_tokens, 'Green') para encontrar linhas em que a text_tokens coluna contém o texto Green. As 1.000 linhas principais são retornadas por uma ordem de reclassificação definida pelo índice de pesquisa.
  • Usa uma função vetorial, DOT_PRODUCT(@vector, embedding), para calcular a similaridade entre o vetor de consulta (@vector) e o vetor de documento armazenado (embedding). Em seguida, classifica os resultados e retorna as 10 principais correspondências finais.
SELECT key
FROM (
  SELECT key, embedding
  FROM hybrid_search
  WHERE SEARCH (text_tokens, 'Green')
  ORDER BY presort
  LIMIT 1000)
ORDER BY DOT_PRODUCT(@vector, embedding) DESC
LIMIT 10;

ML reranking

A reclassificação baseada em ML é uma abordagem computacionalmente intensiva, mas altamente precisa. Ela aplica um modelo de machine learning a um pequeno conjunto de candidatos que foi reduzido pela FTS, pela pesquisa vetorial ou por uma combinação de ambos. Para mais informações sobre a integração do Agent Platform do Spanner, consulte a visão geral da integração do Agent Platform do Spanner.

É possível integrar a reclassificação de ML usando a função ML.PREDICT do Spanner com um modelo implantado do Gemini Enterprise Agent Platform.

Implementar a reclassificação baseada em ML

  1. Implante um modelo de reclassificação (como o do HuggingFace) em um endpoint da plataforma de agentes.

  2. Crie um objeto MODEL do Spanner que aponte para o endpoint do Agent Platform. Por exemplo, no exemplo de modelo Reranker a seguir:

    • text ARRAY<string(max)> são os documentos.
    • text_pair ARRAY<string(max)> é o texto da consulta no exemplo.
    • score são as pontuações de relevância atribuídas pelo modelo de ML para os pares de textos de entrada.
    CREATE MODEL Reranker
INPUT (text ARRAY<string(max)>, text_pair ARRAY<string(max)>)
OUTPUT (score FLOAT32)
REMOTE
OPTIONS (
endpoint = '...'
);

  3. Use uma subconsulta para recuperar os candidatos iniciais (como os 100 principais resultados de uma pesquisa de ANN) e transmiti-los para ML.PREDICT. A função retorna uma nova coluna de pontuação para a ordem final.

    SELECT key
FROM ML.PREDICT(
    MODEL Reranker, (
      SELECT key, text, "gift for 8-year-old" AS text_pair
      FROM hybrid_search
      WHERE embedding IS NOT NULL
      ORDER BY APPROX_DOT_PRODUCT(@vector, embedding, options=>JSON '{"num_leaves_to_search": 50}') DESC
      LIMIT 100)
)
ORDER BY score DESC
LIMIT 3;

A seguir