Boost RankerCompatible with Milvus v2.6.2+

Em vez de depender apenas da semelhança semântica calculada com base em distâncias vectoriais, os Boost Rankers permitem-lhe influenciar os resultados da pesquisa de uma forma significativa. É ideal para ajustar rapidamente os resultados da pesquisa utilizando a filtragem de metadados.

Quando um pedido de pesquisa inclui uma função Boost Ranker, o Milvus utiliza a condição de filtragem opcional dentro da função para encontrar correspondências entre os candidatos a resultados de pesquisa e aumenta as pontuações dessas correspondências aplicando o peso especificado, ajudando a promover ou rebaixar as classificações das entidades correspondentes no resultado final.

Quando usar o Boost Ranker

Ao contrário de outros classificadores que dependem de modelos de codificadores cruzados ou algoritmos de fusão, um Boost Ranker injeta diretamente regras opcionais orientadas por metadados no processo de classificação, o que o torna mais adequado nos seguintes cenários.

Caso de uso	Exemplos	Por que o Boost Ranker funciona bem
Priorização de conteúdo orientado para o negócio	Destacar produtos premium nos resultados de pesquisa de comércio eletrónico Aumentar a visibilidade do conteúdo com métricas de envolvimento do utilizador elevadas (tais como visualizações, gostos e partilhas) Elevar o conteúdo recente em aplicativos de pesquisa sensíveis ao tempo Dar prioridade a conteúdos de fontes verificadas ou fiáveis Impulsionar os resultados que correspondem a frases exactas ou palavras-chave de elevada relevância	Sem a necessidade de reconstruir índices ou modificar modelos de incorporação de vectores - operações que podem consumir muito tempo - pode promover ou despromover instantaneamente itens específicos nos resultados de pesquisa, aplicando filtros de metadados opcionais em tempo real. Este mecanismo permite classificações de pesquisa flexíveis e dinâmicas que se adaptam facilmente à evolução dos requisitos comerciais.
Classificação inferior estratégica de conteúdos	Reduzir a proeminência de itens com pouco inventário sem os remover completamente Diminuir a classificação de conteúdos com termos potencialmente censuráveis sem censura Desvalorização de documentação mais antiga, mantendo-a acessível em pesquisas técnicas Reduzir subtilmente a visibilidade dos produtos da concorrência nas pesquisas de mercado Diminuir a relevância do conteúdo com indicações de qualidade inferior (tais como problemas de formatação, comprimento mais curto, etc.)

Também é possível combinar vários Boost Rankers para implementar uma estratégia de classificação mais dinâmica e robusta baseada no peso.

Mecanismo do Boost Ranker

O diagrama seguinte ilustra o fluxo de trabalho principal dos Boost Rankers.

Mecanismo do Boost Ranker

Quando insere dados, Milvus distribui-os por segmentos. Durante uma pesquisa, cada segmento retorna um conjunto de candidatos, e Milvus classifica esses candidatos de todos os segmentos para produzir os resultados finais. Quando uma solicitação de pesquisa inclui um Boost Ranker, Milvus aplica-o aos resultados do candidato de cada segmento para evitar a perda potencial de precisão e melhorar a recuperação.

Antes de finalizar os resultados, Milvus processa esses candidatos com o Boost Ranker da seguinte forma:

1. Aplica a expressão de filtragem opcional especificada no Boost Ranker para identificar as entidades que correspondem à expressão.

2. Aplica o peso especificado no Boost Ranker para aumentar as pontuações das entidades identificadas.

Exemplos do Boost Ranker

O exemplo a seguir ilustra o uso de um Boost Ranker em uma pesquisa de vetor único que requer o retorno das cinco entidades mais relevantes e a adição de pesos às pontuações de entidades com o tipo de documento abstrato.

1. Coletar candidatos de resultados de pesquisa em segmentos.

   A tabela a seguir assume que Milvus distribui entidades em dois segmentos(0001 e 0002), com cada segmento retornando cinco candidatos.

   ID	Tipo de documento	Pontuação	Classificação	segmento
   117	abstrato	0.344	1	0001
   89	resumo	0.456	2	0001
   257	corpo	0.578	3	0001
   358	título	0.788	4	0001
   168	corpo	0.899	5	0001
   46	corpo	0.189	1	0002
   48	corpo	0265	2	0002
   561	abstrato	0.366	3	0002
   344	resumo	0.444	4	0002
   276	resumo	0.845	5	0002

2. Aplicar a expressão de filtragem especificada no Boost Ranker (doctype='abstract').

   Como indicado pelo campo DocType na tabela seguinte, o Milvus marcará todas as entidades com o seu doctype definido como abstract para processamento posterior.

   ID	Tipo de documento	Pontuação	Classificação	segmento
   117	abstrato	0.344	1	0001
   89	resumo	0.456	2	0001
   257	corpo	0.578	3	0001
   358	título	0.788	4	0001
   168	corpo	0.899	5	0001
   46	corpo	0.189	1	0002
   48	corpo	0265	2	0002
   561	abstrato	0.366	3	0002
   344	resumo	0.444	4	0002
   276	resumo	0.845	5	0002

3. Aplicar o peso especificado no Boost Ranker (weight=0.5).

   Todas as entidades identificadas no passo anterior serão multiplicadas pelo peso especificado no Boost Ranker, resultando em alterações nas suas classificações.

   ID	Tipo de documento	Pontuação	Pontuação ponderada (= pontuação x peso)	Classificação	segmento
   117	abstrato	0.344	0.172	1	0001
   89	abstrato	0.456	0.228	2	0001
   257	corpo	0.578	0.578	3	0001
   358	título	0.788	0.788	4	0001
   168	corpo	0.899	0.899	5	0001
   561	abstrato	0.366	0.183	1	0002
   46	corpo	0.189	0.189	2	0002
   344	abstrato	0.444	0.222	3	0002
   48	corpo	0.265	0.265	4	0002
   276	abstrato	0.845	0.423	5	0002

   O peso deve ser um número de ponto flutuante escolhido por si. Em casos como o exemplo acima, em que uma pontuação menor indica maior relevância, use um peso menor que 1. Caso contrário, use um peso maior que 1.

4. Agregue os candidatos de todos os segmentos com base nas pontuações ponderadas para finalizar os resultados.

   ID	Tipo de documento	Pontuação	Pontuação ponderada	Classificação	segmento
   117	abstrato	0.344	0.172	1	0001
   561	abstrato	0.366	0.183	2	0002
   46	corpo	0.189	0.189	3	0002
   344	abstrato	0.444	0.222	4	0002
   89	abstrato	0.456	0.228	5	0001

Utilização do Boost Ranker

Nesta secção, verá exemplos de como utilizar o Boost Ranker para influenciar os resultados de uma pesquisa de vetor único.

Criar um Boost Ranker

Antes de passar um Boost Ranker como o reranker de uma solicitação de pesquisa, você deve definir corretamente o Boost Ranker como uma função de reranking da seguinte forma:

from pymilvus import Function, FunctionType

ranker = Function(
    name="boost",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "boost",
        "filter": "doctype == 'abstract'",
        "random_score": { 
            "seed": 126,
            "field": "id"
        },
        "weight": 0.5
    }
)

import io.milvus.v2.service.vector.request.ranker.BoostRanker;

BoostRanker ranker = BoostRanker.builder()
        .name("boost")
        .filter("doctype == \"abstract\"")
        .weight(5.0f)
        .randomScoreField("id")
        .randomScoreSeed(126)
        .build();

// go

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

const ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    filter: "doctype == 'abstract'",
    random_score: {
      seed: 126,
      field: "id",
    },
    weight: 0.5,
  },
};

# restful

Parâmetro	Necessário?	Descrição	Valor/exemplo
name	Sim	Identificador único para esta função	"boost"
input_field_names	Sim	Lista de campos vectoriais aos quais aplicar a função (deve estar vazia para o Boost Ranker)	[]
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 tipo de reranker. Deve ser definido como boost para usar o Boost Ranker.	"boost"
params.weight	Sim	Especifica o peso que será multiplicado pelas pontuações de quaisquer entidades correspondentes nos resultados brutos da pesquisa. O valor deve ser um número de ponto flutuante. Para enfatizar a importância das entidades correspondentes, defina-o para um valor que aumente as pontuações. Para rebaixar as entidades correspondentes, atribua a este parâmetro um valor que diminua suas pontuações.	1
params.filter	Não	Especifica a expressão de filtro que será usada para corresponder entidades entre as entidades do resultado da pesquisa. Pode ser qualquer expressão de filtro básico válida mencionada em Filtragem explicada. Nota: Utilize apenas operadores básicos, tais como ==, >, ou <. A utilização de operadores avançados, tais como text_match ou phrase_match, irá degradar o desempenho da pesquisa.	"doctype == 'abstract'"
params.random_score	Não	Especifica a função aleatória que gera um valor entre 0 e 1 aleatoriamente. Tem os dois argumentos opcionais seguintes: seed (number) Especifica um valor inicial utilizado para iniciar um gerador de números pseudo-aleatórios (PRNG). field (string) Especifica o nome de um campo cujo valor será utilizado como um fator aleatório na geração do número aleatório. Um campo com valores únicos será suficiente. É aconselhável definir seed e field para garantir a consistência entre as gerações, usando os mesmos valores de campo e semente.	{"seed": 126, "field": "id"}

Pesquisar com um único Boost Ranker

Quando a função do Boost Ranker estiver pronta, pode referenciá-la num pedido de pesquisa. O exemplo a seguir pressupõe que você já criou uma coleção que tem os seguintes campos: id, vetor e doctype.

from pymilvus import MilvusClient

# Connect to the Milvus server
client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

# Assume you have a collection set up

# Conduct a similarity search using the created ranker
client.search(
    collection_name="my_collection",
    data=[[-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911]],
    anns_field="vector",
    params={},
    output_field=["doctype"],
    ranker=ranker
)

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

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build());
        
SearchResp searchReq = client.search(SearchReq.builder()
        .collectionName("my_collection")
        .data(Collections.singletonList(new FloatVec(new float[]{-0.619954f, 0.447943f, -0.174938f, -0.424803f, -0.864845f})))
        .annsField("vector")
        .outputFields(Collections.singletonList("doctype"))
        .functionScore(FunctionScore.builder()
                .addFunction(ranker)
                .build())
        .build());
SearchResp searchResp = client.search(searchReq);

// go

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

// Connect to the Milvus server
const client = new MilvusClient({
  address: 'localhost:19530',
  token: 'root:Milvus'
});

// Assume you have a collection set up

// Conduct a similarity search
const searchResults = await client.search({
  collection_name: 'my_collection',
  data: [-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911],
  anns_field: 'vector',
  output_fields: ['doctype'],
  rerank: ranker,
});

console.log('Search results:', searchResults);

# restful

Pesquisar com vários Boost Rankers

Você pode combinar vários Boost Rankers em uma única pesquisa para influenciar os resultados da pesquisa. Para isso, crie vários Boost Rankers, faça referência a eles em uma instância do FunctionScore e use a instância do FunctionScore como o classificador na solicitação de pesquisa.

O exemplo a seguir mostra como modificar as pontuações de todas as entidades identificadas aplicando um peso entre 0,8 e 1,2.

from pymilvus import MilvusClient, Function, FunctionType, FunctionScore

# Create a Boost Ranker with a fixed weight
fix_weight_ranker = Function(
    name="boost",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "boost",
        "weight": 0.8
    }
)

# Create a Boost Ranker with a randomly generated weight between 0 and 0.4
random_weight_ranker = Function(
    name="boost",
    input_field_names=[], # Must be an empty list
    function_type=FunctionType.RERANK,
    params={
        "reranker": "boost",
        "random_score": {
            "seed": 126,
        },
        "weight": 0.4
    }
)

# Create a Function Score
ranker = FunctionScore(
    functions=[
        fix_weight_ranker, 
        random_weight_ranker
    ],
    params={
        "boost_mode": "Multiply",
        "function_mode": "Sum"
    }
)

# Conduct a similarity search using the created Function Score
client.search(
    collection_name="my_collection",
    data=[[-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911]],
    anns_field="vector",
    params={},
    output_field=["doctype"],
    ranker=ranker
)

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

CreateCollectionReq.Function fixWeightRanker = CreateCollectionReq.Function.builder()
                 .functionType(FunctionType.RERANK)
                 .name("boost")
                 .param("reranker", "boost")
                 .param("weight", "0.8")
                 .build();
                 
CreateCollectionReq.Function randomWeightRanker = CreateCollectionReq.Function.builder()
                 .functionType(FunctionType.RERANK)
                 .name("boost")
                 .param("reranker", "boost")
                 .param("weight", "0.4")
                 .param("random_score", "{\"seed\": 126}")
                 .build();

Map<String, String> params = new HashMap<>();
params.put("boost_mode","Multiply");
params.put("function_mode","Sum");     
FunctionScore ranker = FunctionScore.builder()
                 .addFunction(fixWeightRanker)
                 .addFunction(randomWeightRanker)
                 .params(params)
                 .build()

SearchResp searchReq = client.search(SearchReq.builder()
                 .collectionName("my_collection")
                 .data(Collections.singletonList(new FloatVec(new float[]{-0.619954f, 0.447943f, -0.174938f, -0.424803f, -0.864845f})))
                 .annsField("vector")
                 .outputFields(Collections.singletonList("doctype"))
                 .addFunction(ranker)
                 .build());
SearchResp searchResp = client.search(searchReq);

// go

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

const fix_weight_ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    weight: 0.8,
  },
};

const random_weight_ranker = {
  name: "boost",
  input_field_names: [],
  type: FunctionType.RERANK,
  params: {
    reranker: "boost",
    random_score: {
      seed: 126,
    },
    weight: 0.4,
  },
};

const ranker = {
  functions: [fix_weight_ranker, random_weight_ranker],
  params: {
    boost_mode: "Multiply",
    function_mode: "Sum",
  },
};

await client.search({
  collection_name: "my_collection",
  data: [[-0.619954382375778, 0.4479436794798608, -0.17493894838751745, -0.4248030059917294, -0.8648452746018911]],
  anns_field: "vector",
  params: {},
  output_field: ["doctype"],
  ranker: ranker
});

# restful

Especificamente, existem dois Boost Rankers: um aplica um peso fixo a todas as entidades encontradas, enquanto o outro atribui um peso aleatório a elas. Em seguida, fazemos referência a esses dois classificadores em um FunctionScore, que também define como os pesos influenciam as pontuações das entidades encontradas.

A tabela seguinte lista os parâmetros necessários para criar uma instância FunctionScore.

Parâmetro	Necessário?	Descrição	Valor/exemplo
functions	Sim	Especifica os nomes dos classificadores de destino numa lista.	["fix_weight_ranker", "random_weight_ranker"]
params.boost_mode	Não	Especifica como os pesos especificados influenciam as pontuações de quaisquer entidades correspondentes. Os valores possíveis são: Multiply Indica que o valor ponderado é igual à pontuação original de uma entidade correspondente multiplicada pelo peso especificado. Este é o valor padrão. Sum Indica que o valor ponderado é igual à soma da pontuação original de uma entidade correspondente e o peso especificado	"Sum"
params.function_mode	Não	Especifica como os valores ponderados de vários Boost Rankers são processados. Os valores possíveis são: Multiply Indica que a pontuação final de uma entidade correspondente é igual ao produto dos valores ponderados de todos os Boost Rankers. Este é o valor padrão. Sum Indica que a pontuação final de uma entidade correspondente é igual à soma dos valores ponderados de todos os Boost Rankers.	"Sum"