Clasificador ponderado

Weighted Ranker combina y prioriza de forma inteligente los resultados de múltiples rutas de búsqueda asignando diferentes pesos de importancia a cada una de ellas. De forma similar a como un chef experto equilibra varios ingredientes para crear el plato perfecto, Weighted Ranker equilibra diferentes resultados de búsqueda para ofrecer los resultados combinados más relevantes. Este enfoque es ideal cuando se buscan múltiples campos vectoriales o modalidades en las que ciertos campos deberían contribuir de forma más significativa que otros a la clasificación final.

Cuándo utilizar Weighted Ranker

El Clasificador ponderado está diseñado específicamente para escenarios de búsqueda híbrida en los que es necesario combinar resultados de múltiples rutas de búsqueda vectorial. Es particularmente eficaz para:

Si su aplicación de búsqueda híbrida requiere combinar varias rutas de búsqueda y controlar su importancia relativa, Weighted Ranker es la opción ideal.

Mecanismo del Clasificador ponderado

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

1. Recopilar puntuaciones de búsqueda: Recopilar los resultados y puntuaciones de cada ruta de búsqueda vectorial (puntuación_1, puntuación_2).

2. Normalización de puntuaciones: Cada búsqueda puede utilizar diferentes métricas de similitud, lo que resulta en distribuciones de puntuación variadas. Por ejemplo, si se utiliza el producto interior (PI) como tipo de similitud, las puntuaciones pueden oscilar entre [-∞,+∞], mientras que si se utiliza la distancia euclídea (L2), las puntuaciones oscilan entre [0,+∞]. Dado que los rangos de puntuación de las distintas búsquedas varían y no pueden compararse directamente, es necesario normalizar las puntuaciones de cada ruta de búsqueda. Normalmente, se aplica la función arctan para transformar las puntuaciones en un rango entre [0, 1] (puntuación_1_normalizada, puntuación_2_normalizada). Las puntuaciones más cercanas a 1 indican una mayor similitud.

3. Asignar pesos: En función de la importancia asignada a los distintos campos vectoriales, se asignan pesos(wi) a las puntuaciones normalizadas (puntuación_1_normalizada, puntuación_2_normalizada). Los pesos de cada ruta deben oscilar entre [0,1]. Las puntuaciones ponderadas resultantes son puntuación_1_ponderada y puntuación_2_ponderada.

4. Fusionar puntuaciones: Las puntuaciones ponderadas (puntuación_1_ponderada, puntuación_2_ponderada) se ordenan de mayor a menor para producir un conjunto final de puntuaciones (puntuación_final).

Clasificador ponderado

Ejemplo de clasificador ponderado

Este ejemplo muestra una búsqueda híbrida multimodal (topK=5) que incluye imágenes y texto e ilustra cómo la estrategia WeightedRanker reordena los resultados de dos búsquedas RNA.

• Resultados de la búsqueda RNA en imágenes （topK=5)：

  ID	Puntuación (imagen)
  101	0.92
  203	0.88
  150	0.85
  198	0.83
  175	0.8

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

  ID	Puntuación (texto)
  198	0.91
  101	0.87
  110	0.85
  175	0.82
  250	0.78

• Utilice WeightedRanker para asignar ponderaciones a los resultados de la búsqueda de imágenes y de texto. Supongamos que la ponderación para la búsqueda RNA de imagen es 0,6 y la ponderación para la búsqueda de texto es 0,4.

  ID	Puntuación (imagen)	Puntuación (texto)	Puntuación ponderada
  101	0.92	0.87	0.6×0.92+0.4×0.87=0.90
  203	0.88	0,88	0.6×0.88+0.4×0=0.528
  150	0.85	N/A	0.6×0.85+0.4×0=0.51
  198	0.83	0.91	0.6×0.83+0.4×0.91=0.86
  175	0.80	0.82	0.6×0.80+0.4×0.82=0.81
  110	No en la imagen	0.85	0.6×0+0.4×0.85=0.34
  250	No en la imagen	0.78	0.6×0+0.4×0.78=0.312

• Los resultados finales después de reranking（topK=5)：

  Clasificación	ID	Puntuación final
  1	101	0.90
  2	198	0.86
  3	175	0.81
  4	203	0.528
  5	150	0.51

Uso de Weighted Ranker

Cuando se utiliza la estrategia WeightedRanker, es necesario introducir valores de ponderación. El número de valores de ponderación a introducir debe corresponder al número de peticiones de búsqueda de RNA básicas en la búsqueda híbrida. Los valores de ponderación deben estar comprendidos entre [0,1], y los valores más próximos a 1 deben indicar una mayor importancia.

Creación de un clasificador ponderado

Por ejemplo, supongamos que en una búsqueda híbrida hay dos peticiones básicas de búsqueda RNA: búsqueda de texto y búsqueda de imágenes. Si la búsqueda de texto se considera más importante, se le asignará un peso mayor.

from pymilvus import Function, FunctionType

rerank = Function(
    name="weight",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "weighted", 
        "weights": [0.1, 0.9],
        "norm_score": True  # Optional
    }
)

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

CreateCollectionReq.Function rerank = CreateCollectionReq.Function.builder()
                .name("weight")
                .functionType(FunctionType.RERANK)
                .param("reranker", "weighted")
                .param("weights", "[0.1, 0.9]")
                .param("norm_score", "true")
                .build();

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

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

// Go

# Restful

Aplicar a la búsqueda híbrida

Weighted Ranker está diseñado específicamente para operaciones de búsqueda híbrida que combinan múltiples campos vectoriales. Al realizar una búsqueda híbrida, debes especificar los pesos para cada ruta de búsqueda:

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 Weighted Ranker to product hybrid search
# Text search has 0.8 weight, image search has 0.3 weight
hybrid_results = milvus_client.hybrid_search(
    collection_name,
    [text_search, image_search],  # Multiple search requests
    ranker=rerank,  # Apply the weighted 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 rerank = {
  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,
  limit: 10,
  data: [text_search, image_search],
  rerank: rerank,
  output_fields = ["product_name", "price", "category"],
});

// go

# restful

Para obtener más información sobre la búsqueda híbrida, consulte Búsqueda híbrida multivectorial.