Clasificador RRF

Reciprocal Rank Fusion (RRF) Ranker es una estrategia de reordenación para la búsqueda híbrida Milvus que equilibra los resultados de múltiples rutas de búsqueda vectorial basándose en sus posiciones de clasificación en lugar de en sus puntuaciones de similitud brutas. Al igual que en un torneo deportivo en el que se tienen en cuenta las clasificaciones de los jugadores en lugar de las estadísticas individuales, el RRF Ranker combina los resultados de la búsqueda en función de la posición que ocupa cada elemento en las distintas rutas de búsqueda, creando una clasificación final justa y equilibrada.

Cuándo utilizar el RRF Ranker

El RRF Ranker se ha diseñado específicamente para situaciones de búsqueda híbrida en las que se desea equilibrar los resultados de varias rutas de búsqueda vectorial sin asignar ponderaciones de importancia explícitas. Es particularmente eficaz para:

Caso de uso	Ejemplo	Por qué funciona bien el RRF Ranker
Búsqueda multimodal con igual importancia	Búsqueda imagen-texto en la que ambas modalidades tienen la misma importancia	Equilibra los resultados sin necesidad de asignar pesos arbitrarios
Búsqueda vectorial conjunta	Combinación de resultados de diferentes modelos de incrustación	Fusiona democráticamente las clasificaciones sin favorecer la distribución de la puntuación de ningún modelo en particular.
Búsqueda multilingüe	Búsqueda de documentos en varios idiomas	Clasifica los resultados de forma equitativa independientemente de las características de incrustación específicas de cada idioma.
Recomendaciones de expertos	Combinación de recomendaciones de varios sistemas expertos	Crea clasificaciones de consenso cuando los distintos sistemas utilizan métodos de puntuación incomparables

Si su aplicación de búsqueda híbrida requiere equilibrar múltiples rutas de búsqueda democráticamente sin asignar pesos explícitos, RRF Ranker es su opción ideal.

Mecanismo del RRF Ranker

El flujo de trabajo principal de la estrategia RRFRanker es el siguiente:

1. Recopilar rankings de búsqueda: Recopila los rankings de resultados de cada ruta de búsqueda vectorial (rank_1, rank_2).

2. Combinar clasificaciones: Convertir las clasificaciones de cada ruta (rank_rrf_1, rank_rrf_2) de acuerdo con una fórmula.

   En la fórmula de cálculo interviene N, que representa el número de recuperaciones. ranki(d) es la posición en la clasificación del documento d generada por el recuperador i(th). k es un parámetro de suavizado que suele fijarse en 60.

3. Clasificación agregada: Vuelve a clasificar los resultados de la búsqueda basándose en las clasificaciones combinadas para producir los resultados finales.

Clasificador RRF

Ejemplo de RRF Ranker

Este ejemplo muestra una búsqueda híbrida (topK=5) en vectores dispersos y densos e ilustra cómo la estrategia RRFRanker vuelve a clasificar los resultados de dos búsquedas RNA.

• Resultados de la búsqueda RNA en vectores dispersos de textos （topK=5)：

  ID	Rango (disperso)
  101	1
  203	2
  150	3
  198	4
  175	5

• Resultados de la búsqueda RNA en vectores densos de textos （topK=5)：

  ID	Rango (denso)
  198	1
  101	2
  110	3
  175	4
  250	5

• Utilice RRF para reordenar las clasificaciones de los dos conjuntos de resultados de búsqueda. Suponga que el parámetro de suavizado k está fijado en 60.

  ID	Puntuación (dispersa)	Puntuación (densa)	Puntuación 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

• Los resultados finales tras la reordenación（topK=5)：

  Clasificación	ID	Puntuación 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

Uso del RRF Ranker

Cuando se utiliza la estrategia de reordenación RRF, es necesario configurar el parámetro k. Se trata de un parámetro de suavizado que puede alterar eficazmente los pesos relativos de la búsqueda de texto completo frente a la búsqueda vectorial. El valor por defecto de este parámetro es 60, y puede ajustarse dentro de un rango de (0, 16384). El valor debe ser un número de coma flotante. El valor recomendado está entre [10, 100]. Aunque k=60 es una opción habitual, el valor óptimo de k puede variar en función de sus aplicaciones y conjuntos de datos específicos. Le recomendamos que pruebe y ajuste este parámetro en función de su caso de uso específico para obtener el mejor rendimiento.

Crear un clasificador RRF

Después de configurar su colección con múltiples campos vectoriales, cree un RRF Ranker con un parámetro de suavizado apropiado:

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	Obligatorio	Descripción	Valor/Ejemplo
name	Sí	Identificador único para esta función	"rrf"
input_field_names	Sí	Lista de campos vectoriales a los que aplicar la función (debe estar vacía para RRF Ranker)	[]
function_type	Sí	Tipo de función a invocar; utilice RERANK para especificar una estrategia de reordenación	FunctionType.RERANK
params.reranker	Sí	Especifica el método de reordenación que se va a utilizar. Debe definirse como rrf para utilizar RRF Ranker.	"weighted"
params.k	No	Parámetro de suavizado que controla el impacto de los rangos de los documentos; un valor más alto en k reduce la sensibilidad a los rangos superiores. Rango: (0, 16384); por defecto: 60. Para más detalles, consulte Mecanismo del RRF Ranker.	100

Aplicación a la búsqueda híbrida

El RRF Ranker está diseñado específicamente para operaciones de búsqueda híbrida que combinan múltiples campos vectoriales. A continuación se explica cómo utilizarlo en una búsqueda 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 obtener más información sobre la búsqueda híbrida, consulta Búsqueda híbrida multivectorial.