Classificador RRF

O Reciprocal Rank Fusion (RRF) Ranker é uma estratégia de reranking para a pesquisa híbrida Milvus que equilibra os resultados de vários caminhos de pesquisa vetorial com base nas suas posições de classificação em vez das suas pontuações de semelhança brutas. Como um torneio desportivo que considera as classificações dos jogadores em vez das estatísticas individuais, o RRF Ranker combina os resultados da pesquisa com base na classificação de cada item em diferentes caminhos de pesquisa, criando uma classificação final justa e equilibrada.

Quando usar o RRF Ranker

O RRF Ranker foi especificamente concebido para cenários de pesquisa híbrida em que se pretende equilibrar os resultados de vários caminhos de pesquisa vetorial sem atribuir pesos de importância explícitos. Ele é particularmente eficaz para:

Caso de uso	Exemplo de uso	Por que o RRF Ranker funciona bem
Pesquisa multimodal com igual importância	Pesquisa de imagem-texto em que ambas as modalidades têm a mesma importância	Equilibra os resultados sem exigir atribuições arbitrárias de pesos
Pesquisa de vectores em conjunto	Combinação de resultados de diferentes modelos de incorporação	Combina democraticamente as classificações sem favorecer a distribuição de pontuação de nenhum modelo em particular
Pesquisa multilingue	Encontrar documentos em vários idiomas	Classifica os resultados de forma justa, independentemente das caraterísticas de incorporação específicas do idioma
Recomendações de especialistas	Combinação de recomendações de vários sistemas especializados	Cria classificações consensuais quando diferentes sistemas utilizam métodos de pontuação incomparáveis

Se a sua aplicação de pesquisa híbrida requer o equilíbrio de múltiplos caminhos de pesquisa democraticamente sem atribuir pesos explícitos, o RRF Ranker é a sua escolha ideal.

Mecanismo do RRF Ranker

O fluxo de trabalho principal da estratégia do RRFRanker é o seguinte:

1. Recolher os rankings de pesquisa: Recolhe as classificações dos resultados de cada caminho da pesquisa vetorial (rank_1, rank_2).

2. Fundir classificações: Converter as classificações de cada caminho (rank_rrf_1, rank_rrf_2) de acordo com uma fórmula.

   A fórmula de cálculo envolve N, que representa o número de recuperações. ranki(d) é a posição de classificação do documento d gerada pelo i(th) retriever. k é um parâmetro de suavização normalmente definido como 60.

3. Agregação de classificações: Classifica novamente os resultados da pesquisa com base nas classificações combinadas para produzir os resultados finais.

Classificador RRF

Exemplo de RRF Ranker

Este exemplo demonstra uma Pesquisa Híbrida (topK=5) em vetores esparso-densos e ilustra como a estratégia RRFRanker reordena os resultados de duas pesquisas ANN.

• Resultados da pesquisa ANN em vectores esparsos de textos （topK=5)：

  ID	Classificação (esparso)
  101	1
  203	2
  150	3
  198	4
  175	5

• Resultados da pesquisa ANN em vectores densos de textos （topK=5)：

  ID	Classificação (denso)
  198	1
  101	2
  110	3
  175	4
  250	5

• Utilize a FRR para reorganizar as classificações dos dois conjuntos de resultados de pesquisa. Suponha que o parâmetro de suavização k está definido para 60.

  ID	Pontuação (esparso)	Pontuação (Densa)	Pontuação final
  101	1	2	1/(60+1)+1/(60+2) = 0.03252247
  198	4	1	1/(60+4)+1/(60+1) = 0.03201844
  175	5	4	1/(60+5)+1/(60+4) = 0.03100962
  203	2	N/A	1/(60+2) = 0.01612903
  150	3	N/A	1/(60+3) = 0.01587302
  110	N/A	3	1/(60+3) = 0.01587302
  250	N/A	5	1/(60+5) = 0.01538462

• Os resultados finais após a reclassificação（topK=5)：

  Classificação	ID	Pontuação final
  1	101	0.03252247
  2	198	0.03201844
  3	175	0.03100962
  4	203	0.01612903
  5	150	0.01587302
  5	110	0.01587302

Utilização do RRF Ranker

Ao usar a estratégia de reranking RRF, é necessário configurar o parâmetro k. Trata-se de um parâmetro de suavização que pode alterar eficazmente os pesos relativos da pesquisa de texto completo em relação à pesquisa de vectores. O valor padrão deste parâmetro é 60, e pode ser ajustado dentro de um intervalo de (0, 16384). O valor deve ser um número de ponto flutuante. O valor recomendado é entre [10, 100]. Embora k=60 seja uma escolha comum, o valor ideal de k pode variar dependendo das suas aplicações e conjuntos de dados específicos. Recomendamos testar e ajustar esse parâmetro com base no seu caso de uso específico para obter o melhor desempenho.

Criar um classificador RRF

Depois de a sua coleção estar configurada com vários campos vectoriais, crie um RRF Ranker com um parâmetro de suavização adequado:

from pymilvus import Function, FunctionType

ranker = Function(
    name="rrf",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "rrf", 
        "k": 100  # Optional
    }
)

import io.milvus.common.clientenum.FunctionType;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

CreateCollectionReq.Function rerank = CreateCollectionReq.Function.builder()
        .name("rrf")
        .functionType(FunctionType.RERANK)
        .param("reranker", "rrf")
        .param("k", "100")
        .build();

import { FunctionType } from "@zilliz/milvus2-sdk-node";

const ranker = {
  name: "weight",
  input_field_names: [],
  function_type: FunctionType.RERANK,
  params: {
    reranker: "weighted",
    weights: [0.1, 0.9],
    norm_score: true,
  },
};

// Go

# Restful

Parâmetro	Necessário?	Descrição	Valor/Exemplo
name	Sim	Identificador único para esta função	"rrf"
input_field_names	Sim	Lista de campos vectoriais aos quais aplicar a função (deve estar vazia para o RRF Ranker)	[]
function_type	Sim	O tipo de função a invocar; utilizar RERANK para especificar uma estratégia de classificação	FunctionType.RERANK
params.reranker	Sim	Especifica o método de reordenação a utilizar. Deve ser definido como rrf para utilizar o RRF Ranker.	"weighted"
params.k	Não	Parâmetro de suavização que controla o impacto das classificações dos documentos; um k mais elevado reduz a sensibilidade às classificações de topo. Intervalo: (0, 16384); predefinição: 60. Para obter detalhes, consulte Mecanismo do RRF Ranker.	100

Aplicar à pesquisa híbrida

O RRF Ranker foi concebido especificamente para operações de pesquisa híbrida que combinam vários campos vectoriais. Veja como usá-lo em uma busca híbrida:

from pymilvus import MilvusClient, AnnSearchRequest

# Connect to Milvus server
milvus_client = MilvusClient(uri="http://localhost:19530")

# Assume you have a collection setup

# Define text vector search request
text_search = AnnSearchRequest(
    data=["modern dining table"],
    anns_field="text_vector",
    param={},
    limit=10
)

# Define image vector search request
image_search = AnnSearchRequest(
    data=[image_embedding],  # Image embedding vector
    anns_field="image_vector",
    param={},
    limit=10
)

# Apply RRF Ranker to product hybrid search
# The smoothing parameter k controls the balance
hybrid_results = milvus_client.hybrid_search(
    collection_name,
    [text_search, image_search],  # Multiple search requests
    ranker=ranker,  # Apply the RRF ranker
    limit=10,
    output_fields=["product_name", "price", "category"]
)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.AnnSearchReq;
import io.milvus.v2.service.vector.request.HybridSearchReq;
import io.milvus.v2.service.vector.response.SearchResp;
import io.milvus.v2.service.vector.request.data.EmbeddedText;
import io.milvus.v2.service.vector.request.data.FloatVec;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .build());
        
List<AnnSearchReq> searchRequests = new ArrayList<>();
searchRequests.add(AnnSearchReq.builder()
        .vectorFieldName("text_vector")
        .vectors(Collections.singletonList(new EmbeddedText("\"modern dining table\"")))
        .limit(10)
        .build());
searchRequests.add(AnnSearchReq.builder()
        .vectorFieldName("image_vector")
        .vectors(Collections.singletonList(new FloatVec(imageEmbedding)))
        .limit(10)
        .build());
        
HybridSearchReq hybridSearchReq = HybridSearchReq.builder()
                .collectionName(COLLECTION_NAME)
                .searchRequests(searchRequests)
                .ranker(ranker)
                .limit(10)
                .outputFields(Arrays.asList("product_name", "price", "category"))
                .build();
SearchResp searchResp = client.hybridSearch(hybridSearchReq);

import { MilvusClient, FunctionType } from "@zilliz/milvus2-sdk-node";

const milvusClient = new MilvusClient({ address: "http://localhost:19530" });

const text_search = {
    data: ["modern dining table"],
    anns_field: "text_vector",
    param: {},
    limit: 10,
};

const image_search = {
  data: [image_embedding],
  anns_field: "image_vector",
  param: {},
  limit: 10,
};

const ranker = {
  name: "weight",
  input_field_names: [],
  function_type: FunctionType.RERANK,
  params: {
    reranker: "weighted",
    weights: [0.1, 0.9],
    norm_score: true,
  },
};

const search = await milvusClient.search({
  collection_name: collection_name,
  data: [text_search, image_search],
  output_fields: ["product_name", "price", "category"],
  limit: 10,
  rerank: ranker,
});

// go

# restful

Para obter mais informações sobre a pesquisa híbrida, consulte Pesquisa Híbrida Multi-Vetorial.