Clasificador BoostCompatible with Milvus v2.6.2+

En lugar de basarse únicamente en la similitud semántica calculada a partir de distancias vectoriales, los Boost Rankers permiten influir en los resultados de búsqueda de forma significativa. Es ideal para ajustar rápidamente los resultados de búsqueda mediante el filtrado de metadatos.

Cuando una solicitud de búsqueda incluye una función Boost Ranker, Milvus utiliza la condición de filtrado opcional dentro de la función para encontrar coincidencias entre los candidatos a resultados de búsqueda y aumenta las puntuaciones de esas coincidencias aplicando el peso especificado, ayudando a promover o degradar las clasificaciones de las entidades coincidentes en el resultado final.

Cuándo utilizar Boost Ranker

A diferencia de otros clasificadores que se basan en modelos de codificación cruzada o algoritmos de fusión, un Boost Ranker inyecta directamente reglas opcionales basadas en metadatos en el proceso de clasificación, lo que lo hace más adecuado en los siguientes escenarios.

Casos de uso	Ejemplos	Por qué funciona bien Boost Ranker
Priorización de contenidos en función del negocio	Destacar los productos premium en los resultados de búsqueda de comercio electrónico Aumentar la visibilidad del contenido con métricas de alta participación de los usuarios (como vistas, me gusta y compartidos) Elevar el contenido reciente en aplicaciones de búsqueda sensibles al tiempo Dar prioridad al contenido de fuentes verificadas o de confianza Potenciación de los resultados que coinciden con frases exactas o palabras clave de gran relevancia	Sin necesidad de reconstruir los índices o modificar los modelos de incrustación de vectores -operaciones que pueden llevar mucho tiempo-, puede promover o degradar instantáneamente elementos específicos en los resultados de búsqueda aplicando filtros de metadatos opcionales en tiempo real. Este mecanismo permite clasificaciones de búsqueda flexibles y dinámicas que se adaptan fácilmente a la evolución de los requisitos empresariales.
Desclasificación estratégica de contenidos	Reducir la prominencia de los artículos con bajo inventario sin eliminarlos por completo Reducir el rango de los contenidos con términos potencialmente censurables sin censurarlos Degradar la documentación más antigua pero manteniéndola accesible en las búsquedas técnicas Reducir sutilmente la visibilidad de los productos de la competencia en las búsquedas de mercado. Disminuir la relevancia de los contenidos con indicios de menor calidad (como problemas de formato, menor extensión, etc.)

También puede combinar varios Boost Rankers para aplicar una estrategia de clasificación basada en el peso más dinámica y sólida.

Mecanismo del Boost Ranker

El siguiente diagrama ilustra el flujo de trabajo principal de los Boost Rankers.

Mecanismo de Boost Ranker

Cuando se insertan datos, Milvus los distribuye en segmentos. Durante una búsqueda, cada segmento devuelve un conjunto de candidatos, y Milvus clasifica estos candidatos de todos los segmentos para producir los resultados finales. Cuando una solicitud de búsqueda incluye un Boost Ranker, Milvus lo aplica a los resultados de los candidatos de cada segmento para evitar posibles pérdidas de precisión y mejorar la recuperación.

Antes de finalizar los resultados, Milvus procesa estos candidatos con el Boost Ranker como sigue:

1. Aplica la expresión de filtrado opcional especificada en el Boost Ranker para identificar las entidades que coinciden con la expresión.

2. Aplica el peso especificado en el Boost Ranker para aumentar la puntuación de las entidades identificadas.

Ejemplos de Boost Ranker

El siguiente ejemplo ilustra el uso de un Boost Ranker en una búsqueda monovectorial que requiere devolver las cinco entidades más relevantes y añadir pesos a las puntuaciones de las entidades con el tipo doc abstracto.

1. Recoger los candidatos a resultados de búsqueda en segmentos.

   La siguiente tabla supone que Milvus distribuye las entidades en dos segmentos(0001 y 0002), y que cada segmento devuelve cinco candidatos.

   ID	Tipo de documento	Puntuación	Rango	segmento
   117	abstracto	0.344	1	0001
   89	abstracto	0.456	2	0001
   257	cuerpo	0.578	3	0001
   358	título	0.788	4	0001
   168	cuerpo	0.899	5	0001
   46	cuerpo	0.189	1	0002
   48	cuerpo	0265	2	0002
   561	abstracto	0.366	3	0002
   344	abstracto	0.444	4	0002
   276	abstracto	0.845	5	0002

2. Aplique la expresión de filtrado especificada en el Boost Ranker (doctype='abstract').

   Como se indica en el campo DocType de la siguiente tabla, Milvus marcará todas las entidades con su doctype ajustado a abstract para su posterior procesamiento.

   ID	Tipo de documento	Puntuación	Clasificación	segmento
   117	abstracto	0.344	1	0001
   89	abstracto	0.456	2	0001
   257	cuerpo	0.578	3	0001
   358	título	0.788	4	0001
   168	cuerpo	0.899	5	0001
   46	cuerpo	0.189	1	0002
   48	cuerpo	0265	2	0002
   561	abstracto	0.366	3	0002
   344	abstracto	0.444	4	0002
   276	abstracto	0.845	5	0002

3. Aplicar el peso especificado en el Boost Ranker (weight=0.5).

   Todas las entidades identificadas en el paso anterior se multiplicarán por el peso especificado en el Boost Ranker, dando lugar a cambios en sus rangos.

   ID	Tipo de documento	Puntuación	Puntuación ponderada (= puntuación x peso)	Clasificación	segmento
   117	abstracto	0.344	0.172	1	0001
   89	abstracto	0.456	0.228	2	0001
   257	cuerpo	0.578	0.578	3	0001
   358	título	0.788	0.788	4	0001
   168	cuerpo	0.899	0.899	5	0001
   561	abstracto	0.366	0.183	1	0002
   46	cuerpo	0.189	0.189	2	0002
   344	abstracto	0.444	0.222	3	0002
   48	cuerpo	0.265	0.265	4	0002
   276	abstracto	0.845	0.423	5	0002

   La ponderación debe ser un número de coma flotante que usted elija. En casos como el del ejemplo anterior, en el que una puntuación menor indica mayor relevancia, utilice una ponderación menor que 1. En caso contrario, utilice una ponderación mayor que 1.

4. Agregue los candidatos de todos los segmentos basándose en las puntuaciones ponderadas para finalizar los resultados.

   ID	Tipo de documento	Puntuación	Puntuación ponderada	Clasificación	segmento
   117	abstracto	0.344	0.172	1	0001
   561	abstracto	0.366	0.183	2	0002
   46	cuerpo	0.189	0.189	3	0002
   344	abstracto	0.444	0.222	4	0002
   89	abstracto	0.456	0.228	5	0001

Uso de Boost Ranker

En esta sección, verás ejemplos de cómo utilizar Boost Ranker para influir en los resultados de una búsqueda monovectorial.

Crear un Boost Ranker

Antes de pasar un Boost Ranker como reranker de una petición de búsqueda, debes definir correctamente el Boost Ranker como una función reranking como se indica a continuación:

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	Obligatorio	Descripción	Valor/Ejemplo
name	Sí	Identificador único para esta función	"boost"
input_field_names	Sí	Lista de campos vectoriales a los que aplicar la función (debe estar vacía para Boost 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 tipo de reranker. Debe establecerse en boost para utilizar Boost Ranker.	"boost"
params.weight	Sí	Especifica la ponderación que se multiplicará por las puntuaciones de las entidades coincidentes en los resultados de búsqueda sin procesar. El valor debe ser un número de coma flotante. Para resaltar la importancia de las entidades coincidentes, establezca un valor que aumente las puntuaciones. Para degradar las entidades coincidentes, asigne a este parámetro un valor que disminuya sus puntuaciones.	1
params.filter	No	Especifica la expresión de filtro que se utilizará para emparejar entidades entre las entidades de los resultados de búsqueda. Puede ser cualquier expresión de filtro básica válida mencionada en Explicación del filtrado. Nota: Utilice únicamente operadores básicos, como ==, > o <. El uso de operadores avanzados, como text_match o phrase_match, degradará el rendimiento de la búsqueda.	"doctype == 'abstract'"
params.random_score	No	Especifica la función aleatoria que genera un valor entre 0 y 1 de forma aleatoria. Tiene los dos argumentos opcionales siguientes: seed (número) Especifica un valor inicial utilizado para iniciar un generador de números pseudoaleatorios (PRNG). field (cadena) Especifica el nombre de un campo cuyo valor se utilizará como factor aleatorio en la generación del número aleatorio. Un campo con valores únicos será suficiente. Se recomienda definir seed y field para garantizar la coherencia entre generaciones utilizando los mismos valores de semilla y campo.	{"seed": 126, "field": "id"}

Búsqueda con un único Boost Ranker

Una vez que la función Boost Ranker está lista, puede hacer referencia a ella en una petición de búsqueda. El siguiente ejemplo asume que ya has creado una colección que tiene los siguientes campos: id, vector y 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

Búsqueda con varios Boost Rankers

Puedes combinar varios Boost Rankers en una única búsqueda para influir en los resultados de la misma. Para ello, crea varios Boost Rankers, haz referencia a ellos en una instancia de FunctionScore y utiliza la instancia de FunctionScore como clasificador en la solicitud de búsqueda.

El siguiente ejemplo muestra cómo modificar las puntuaciones de todas las entidades identificadas aplicando un peso entre 0.8 y 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

En concreto, existen dos Boost Rankers: uno aplica un peso fijo a todas las entidades encontradas, mientras que el otro les asigna un peso aleatorio. A continuación, referenciamos estos dos rankers en una FunctionScore, que también define cómo influyen los pesos en las puntuaciones de las entidades encontradas.

La siguiente tabla enumera los parámetros necesarios para crear una instancia de FunctionScore.

Parámetro	¿Necesario?	Descripción	Valor/Ejemplo
functions	Sí	Especifica los nombres de los clasificadores de destino en una lista.	["fix_weight_ranker", "random_weight_ranker"]
params.boost_mode	No	Especifica cómo influyen las ponderaciones especificadas en las puntuaciones de las entidades coincidentes. Los valores posibles son: Multiply Indica que el valor ponderado es igual a la puntuación original de una entidad coincidente multiplicada por el peso especificado. Este es el valor por defecto. Sum Indica que el valor ponderado es igual a la suma de la puntuación original de una entidad coincidente y el peso especificado.	"Sum"
params.function_mode	Sin	Especifica cómo se procesan los valores ponderados de varios Boost Rankers. Los valores posibles son: Multiply Indica que la puntuación final de una entidad coincidente es igual al producto de los valores ponderados de todos los Boost Rankers. Este es el valor por defecto. Sum Indica que la puntuación final de una entidad coincidente es igual a la suma de los valores ponderados de todos los Boost Rankers.	"Sum"