Boost RankerCompatible with Milvus v2.6.2+

Au lieu de s'appuyer uniquement sur la similarité sémantique calculée sur la base des distances vectorielles, les Boost Rankers vous permettent d'influencer les résultats de recherche de manière significative. Il est idéal pour ajuster rapidement les résultats de recherche à l'aide du filtrage des métadonnées.

Lorsqu'une demande de recherche inclut une fonction Boost Ranker, Milvus utilise la condition de filtrage facultative dans la fonction pour trouver des correspondances parmi les candidats aux résultats de recherche et augmente les scores de ces correspondances en appliquant le poids spécifié, ce qui permet de promouvoir ou de rétrograder les classements des entités correspondantes dans le résultat final.

Quand utiliser Boost Ranker ?

Contrairement à d'autres outils de classement qui s'appuient sur des modèles d'encodage croisé ou des algorithmes de fusion, un Boost Ranker injecte directement des règles optionnelles basées sur les métadonnées dans le processus de classement, ce qui le rend plus approprié dans les scénarios suivants.

Cas d'utilisation	Exemples de cas d'utilisation	Pourquoi Boost Ranker fonctionne bien
Hiérarchisation du contenu en fonction de l'activité de l'entreprise	Mettre en avant les produits haut de gamme dans les résultats de recherche du commerce électronique Augmenter la visibilité du contenu avec des métriques d'engagement utilisateur élevées (telles que les vues, les likes et les partages) Mettre en avant les contenus récents dans les applications de recherche sensibles au temps Donner la priorité au contenu provenant de sources vérifiées ou fiables Renforcer les résultats correspondant à des expressions exactes ou à des mots-clés très pertinents	Sans avoir à reconstruire les index ou à modifier les modèles d'intégration des vecteurs, opérations qui peuvent prendre beaucoup de temps, vous pouvez instantanément promouvoir ou rétrograder des éléments spécifiques dans les résultats de recherche en appliquant des filtres de métadonnées optionnels en temps réel. Ce mécanisme permet d'obtenir des classements de recherche flexibles et dynamiques qui s'adaptent facilement à l'évolution des besoins de l'entreprise.
Rétrogradation stratégique du contenu	Réduction de la proéminence des éléments à faible inventaire sans les supprimer complètement Abaisser le rang du contenu contenant des termes potentiellement répréhensibles sans le censurer. Rétrograder la documentation plus ancienne tout en la gardant accessible dans les recherches techniques Réduire subtilement la visibilité des produits concurrents dans les recherches sur la place de marché Diminuer la pertinence du contenu avec des indications de qualité inférieure (telles que des problèmes de formatage, une longueur plus courte, etc.)

Vous pouvez également combiner plusieurs Boost Rankers pour mettre en œuvre une stratégie de classement plus dynamique et plus robuste basée sur le poids.

Mécanisme de Boost Ranker

Le diagramme suivant illustre le flux de travail principal des Boost Rankers.

Mécanisme de Boost Ranker

Lorsque vous insérez des données, Milvus les répartit entre les segments. Lors d'une recherche, chaque segment renvoie un ensemble de candidats et Milvus classe ces candidats à partir de tous les segments pour produire les résultats finaux. Lorsqu'une demande de recherche inclut un Boost Ranker, Milvus l'applique aux résultats des candidats de chaque segment afin d'éviter toute perte potentielle de précision et d'améliorer le rappel.

Avant de finaliser les résultats, Milvus traite ces candidats avec le Boost Ranker comme suit :

1. Il applique l'expression de filtrage facultative spécifiée dans le Boost Ranker pour identifier les entités qui correspondent à l'expression.

2. Il applique la pondération spécifiée dans le Boost Ranker pour augmenter les scores des entités identifiées.

Exemples de Boost Ranker

L'exemple suivant illustre l'utilisation d'un Boost Ranker dans une recherche à vecteur unique qui nécessite de renvoyer les cinq entités les plus pertinentes et d'ajouter des poids aux scores des entités ayant le type de document abstrait.

1. Rassembler les candidats aux résultats de la recherche par segments.

   Le tableau suivant suppose que Milvus distribue les entités en deux segments(0001 et 0002), chaque segment renvoyant cinq candidats.

   ID	Type de document	Score	Rang	segment
   117	abstrait	0.344	1	0001
   89	abstrait	0.456	2	0001
   257	corps	0.578	3	0001
   358	titre	0.788	4	0001
   168	corps	0.899	5	0001
   46	corps	0.189	1	0002
   48	corps	0265	2	0002
   561	abstrait	0.366	3	0002
   344	abstrait	0.444	4	0002
   276	abstrait	0.845	5	0002

2. Appliquer l'expression de filtrage spécifiée dans le Boost Ranker (doctype='abstract').

   Comme l'indique le champ DocType dans le tableau suivant, Milvus marquera toutes les entités dont le champ doctype est défini sur abstract pour la suite du traitement.

   ID	DocType	Score	Rang	segment
   117	abstrait	0.344	1	0001
   89	abstrait	0.456	2	0001
   257	corps	0.578	3	0001
   358	titre	0.788	4	0001
   168	corps	0.899	5	0001
   46	corps	0.189	1	0002
   48	corps	0265	2	0002
   561	abstrait	0.366	3	0002
   344	abstrait	0.444	4	0002
   276	abstrait	0.845	5	0002

3. Appliquer le poids spécifié dans le Boost Ranker (weight=0.5).

   Toutes les entités identifiées à l'étape précédente seront multipliées par le poids spécifié dans le Boost Ranker, ce qui modifiera leur classement.

   ID	DocType	Score	Score pondéré (= score x poids)	Rang	segment
   117	abstrait	0.344	0.172	1	0001
   89	abstrait	0.456	0.228	2	0001
   257	corps	0.578	0.578	3	0001
   358	titre	0.788	0.788	4	0001
   168	corps	0.899	0.899	5	0001
   561	abstrait	0.366	0.183	1	0002
   46	corps	0.189	0.189	2	0002
   344	abstrait	0.444	0.222	3	0002
   48	corps	0.265	0.265	4	0002
   276	abstrait	0.845	0.423	5	0002

   La pondération doit être un nombre à virgule flottante que vous choisissez. Dans des cas comme l'exemple ci-dessus, où un score plus faible indique une plus grande pertinence, utilisez une pondération inférieure à 1. Dans le cas contraire, utilisez une pondération supérieure à 1.

4. Agrégez les candidats de tous les segments sur la base des scores pondérés pour finaliser les résultats.

   ID	Type de document	Score	Score pondéré	Rang	segment
   117	abstrait	0.344	0.172	1	0001
   561	abstrait	0.366	0.183	2	0002
   46	corps	0.189	0.189	3	0002
   344	abstrait	0.444	0.222	4	0002
   89	abstrait	0.456	0.228	5	0001

Utilisation de Boost Ranker

Dans cette section, vous verrez des exemples d'utilisation de Boost Ranker pour influencer les résultats d'une recherche sur un seul vecteur.

Créer un Boost Ranker

Avant de passer un Boost Ranker en tant que reranker d'une requête de recherche, vous devez définir correctement le Boost Ranker en tant que fonction de reranking comme suit :

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

Paramètre	Nécessaire ?	Description de la fonction	Valeur/Exemple
name	Oui	Identifiant unique pour cette fonction	"boost"
input_field_names	Oui	Liste des champs vectoriels auxquels appliquer la fonction (doit être vide pour Boost Ranker)	[]
function_type	Oui	Type de fonction à invoquer ; utiliser RERANK pour spécifier une stratégie de reclassement	FunctionType.RERANK
params.reranker	Oui	Spécifie le type de reranker. Doit être défini sur boost pour utiliser Boost Ranker.	"boost"
params.weight	Oui	Spécifie le poids qui sera multiplié par les scores de toutes les entités correspondantes dans les résultats de recherche bruts. La valeur doit être un nombre à virgule flottante. Pour mettre l'accent sur l'importance des entités correspondantes, définissez une valeur qui augmente les scores. Pour rétrograder les entités correspondantes, attribuez à ce paramètre une valeur qui diminue leur score.	1
params.filter	Non	Spécifie l'expression de filtre qui sera utilisée pour faire correspondre les entités parmi les entités des résultats de la recherche. Il peut s'agir de n'importe quelle expression de filtre de base valide mentionnée dans Filtering Explained (Le filtrage expliqué). Remarque: n'utilisez que des opérateurs de base, tels que ==, > ou <. L'utilisation d'opérateurs avancés, tels que text_match ou phrase_match, dégradera les performances de la recherche.	"doctype == 'abstract'"
params.random_score	Non	Spécifie la fonction aléatoire qui génère une valeur entre 0 et 1 de manière aléatoire. Elle possède les deux arguments facultatifs suivants : seed (nombre) Spécifie une valeur initiale utilisée pour démarrer un générateur de nombres pseudo-aléatoires (PRNG). field (string) Spécifie le nom d'un champ dont la valeur sera utilisée comme facteur aléatoire dans la génération du nombre aléatoire. Un champ avec des valeurs uniques suffit. Il est conseillé de définir à la fois seed et field pour garantir la cohérence entre les générations en utilisant les mêmes valeurs de graine et de champ.	{"seed": 126, "field": "id"}

Recherche avec un seul Boost Ranker

Une fois que la fonction Boost Ranker est prête, vous pouvez la référencer dans une requête de recherche. L'exemple suivant suppose que vous avez déjà créé une collection avec les champs suivants : id, vector et 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

Recherche avec plusieurs Boost Rankers

Vous pouvez combiner plusieurs Boost Rankers dans une seule recherche afin d'influencer les résultats de la recherche. Pour ce faire, créez plusieurs Boost Rankers, référencez-les dans une instance de FunctionScore, et utilisez l'instance de FunctionScore comme ranker dans la requête de recherche.

L'exemple suivant montre comment modifier les scores de toutes les entités identifiées en appliquant un poids compris entre 0,8 et 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

Spécifiquement, il y a deux Boost Rankers : l'un applique un poids fixe à toutes les entités trouvées, tandis que l'autre leur attribue un poids aléatoire. Ensuite, nous référençons ces deux Rankers dans une FunctionScore, qui définit également comment les poids influencent les scores des entités trouvées.

Le tableau suivant répertorie les paramètres nécessaires à la création d'une instance de FunctionScore.

Paramètre	Nécessaire ?	Description	Valeur/Exemple
functions	Oui	Spécifie les noms des classeurs cibles dans une liste.	["fix_weight_ranker", "random_weight_ranker"]
params.boost_mode	Non	Indique comment les pondérations spécifiées influencent les scores des entités correspondantes. Les valeurs possibles sont les suivantes : Multiply Indique que la valeur pondérée est égale à la note initiale d'une entité correspondante multipliée par la pondération spécifiée. Il s'agit de la valeur par défaut. Sum Indique que la valeur pondérée est égale à la somme du score original d'une entité correspondante et du poids spécifié.	"Sum"
params.function_mode	Non	Indique comment les valeurs pondérées des différents Boost Rankers sont traitées. Les valeurs possibles sont les suivantes Multiply Indique que le score final d'une entité correspondante est égal au produit des valeurs pondérées de tous les Boost Rankers. Il s'agit de la valeur par défaut. Sum Indique que le score final d'une entité correspondante est égal à la somme des valeurs pondérées de tous les Boost Rankers.	"Sum"