Classificador ponderado

O Weighted Ranker combina e prioriza de forma inteligente os resultados de vários caminhos de pesquisa, atribuindo pesos de importância diferentes a cada um deles. Da mesma forma que um chef habilidoso equilibra vários ingredientes para criar o prato perfeito, o Weighted Ranker equilibra diferentes resultados de pesquisa para fornecer os resultados combinados mais relevantes. Esta abordagem é ideal para pesquisas em vários campos vectoriais ou modalidades em que determinados campos devem contribuir mais significativamente para a classificação final do que outros.

Quando utilizar o Weighted Ranker

O Weighted Ranker foi especificamente concebido para cenários de pesquisa híbrida em que é necessário combinar resultados de vários caminhos de pesquisa vetorial. É particularmente eficaz para:

Caso de uso	Exemplo de uso	Por que o Weighted Ranker funciona bem
Pesquisa de comércio eletrónico	Pesquisa de produtos que combina semelhança de imagem e descrição de texto	Permite que os retalhistas dêem prioridade à semelhança visual para artigos de moda, enquanto dão ênfase às descrições de texto para produtos técnicos
Pesquisa de conteúdos multimédia	Recuperação de vídeos utilizando caraterísticas visuais e transcrições de áudio	Equilibra a importância do conteúdo visual em relação ao diálogo falado com base na intenção da consulta
Recuperação de documentos	Pesquisa de documentos empresariais com múltiplas incorporações para diferentes secções	Dá maior peso às incorporações de título e resumo, sem deixar de considerar as incorporações de texto integral

Se a sua aplicação de pesquisa híbrida requer a combinação de vários caminhos de pesquisa e o controlo da sua importância relativa, o Weighted Ranker é a escolha ideal.

Mecanismo do Weighted Ranker

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

1. Recolher resultados de pesquisa: Reúne os resultados e as pontuações de cada caminho de pesquisa vetorial (pontuação_1, pontuação_2).

2. Normalização da pontuação: Cada pesquisa pode usar métricas de similaridade diferentes, resultando em distribuições de pontuação variadas. Por exemplo, o uso do produto interno (IP) como um tipo de similaridade pode resultar em pontuações que variam de [-∞,+∞], enquanto o uso da distância euclidiana (L2) resulta em pontuações que variam de [0,+∞]. Como os intervalos de pontuação de diferentes pesquisas variam e não podem ser diretamente comparados, é necessário normalizar as pontuações de cada caminho de pesquisa. Normalmente, a função arctan é aplicada para transformar as pontuações num intervalo entre [0, 1] (pontuação_1_normalizada, pontuação_2_normalizada). As pontuações mais próximas de 1 indicam maior similaridade.

3. Atribuir pesos: Com base na importância atribuída aos diferentes campos vectoriais, são atribuídos pesos(wi) às pontuações normalizadas (score_1_normalized, score_2_normalized). Os pesos de cada caminho devem variar entre [0,1]. As pontuações ponderadas resultantes são pontuação_1_ponderada e pontuação_2_ponderada.

4. Mesclar pontuações: As pontuações ponderadas (score_1_weighted, score_2_weighted) são classificadas da mais alta para a mais baixa para produzir um conjunto final de pontuações (score_final).

Classificador ponderado

Exemplo de classificador ponderado

Este exemplo demonstra uma Pesquisa Híbrida multimodal (topK=5) que envolve imagens e texto e ilustra como a estratégia WeightedRanker classifica os resultados de duas pesquisas ANN.

• Resultados da pesquisa ANN em imagens （topK=5)：

  ID	Pontuação (imagem)
  101	0.92
  203	0.88
  150	0.85
  198	0.83
  175	0.8

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

  ID	Pontuação (texto)
  198	0.91
  101	0.87
  110	0.85
  175	0.82
  250	0.78

• Utilize o WeightedRanker para atribuir pesos aos resultados da pesquisa de imagens e de texto. Suponha que o peso para a pesquisa ANN de imagens é 0,6 e o peso para a pesquisa de texto é 0,4.

  ID	Pontuação (imagem)	Pontuação (texto)	Pontuação ponderada
  101	0.92	0.87	0.6×0.92+0.4×0.87=0.90
  203	0.88	N/A	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	Não está na imagem	0.85	0.6×0+0.4×0.85=0.34
  250	Não está na imagem	0.78	0.6×0+0.4×0.78=0.312

• Os resultados finais após o reranking（topK=5)：

  Classificação	ID	Pontuação final
  1	101	0.90
  2	198	0.86
  3	175	0.81
  4	203	0.528
  5	150	0.51

Utilização do Weighted Ranker

Ao utilizar a estratégia WeightedRanker, é necessário introduzir valores de peso. O número de valores de peso a introduzir deve corresponder ao número de pedidos de pesquisa básica da RNA na Pesquisa Híbrida. Os valores de peso de entrada devem estar no intervalo de [0,1], com valores mais próximos de 1 indicando maior importância.

Criar um classificador ponderado

Por exemplo, suponha que existam dois pedidos de pesquisa ANN básicos numa Pesquisa Híbrida: pesquisa de texto e pesquisa de imagem. Se a pesquisa de texto for considerada mais importante, deve ser-lhe atribuído um peso maior.

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

Parâmetro	Necessário?	Descrição	Valor/Exemplo
name	Sim	Identificador único para esta função	"weight"
input_field_names	Sim	Lista de campos vectoriais aos quais aplicar a função (deve estar vazia para a classificação ponderada)	[]
function_type	Sim	O tipo de função a invocar; utilize 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 weighted para utilizar a classificação ponderada.	"weighted"
params.weights	Sim	Matriz de pesos correspondentes a cada caminho de pesquisa; valores ∈ [0,1]. Para obter detalhes, consulte Mecanismo do Weighted Ranker.	[0.1, 0.9]
params.norm_score	Não	Se a pontuação bruta deve ser normalizada (usando arctan) antes da ponderação. Para obter detalhes, consulte Mecanismo do classificador ponderado.	True

Aplicar à pesquisa híbrida

O Weighted Ranker foi concebido especificamente para operações de pesquisa híbrida que combinam vários campos vectoriais. Ao realizar uma pesquisa híbrida, deve especificar os pesos para cada caminho de pesquisa:

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 obter mais informações sobre a pesquisa híbrida, consulte Pesquisa híbrida multivectorial.