Créer une requête hybride dans Recherche Azure AI

La recherche hybride combine du texte (mot clé) et des requêtes vectorielles dans une requête de recherche unique. Les deux requêtes s’exécutent en parallèle. Les résultats sont fusionnés et réorganisés par de nouveaux scores de recherche, à l’aide de la fusion de classement réciproque (RRF) pour obtenir un ensemble de résultats unifié. Dans de nombreux cas, par test de benchmark, les requêtes hybrides avec classement sémantique retournent les résultats les plus pertinents.

Dans cet article, découvrez comment :

• Configurer une requête hybride de base
• Ajouter des paramètres et des filtres
• Améliorer la pertinence à l’aide du classement sémantique ou des pondérations vectorielles
• Optimiser les comportements de requête en contrôlant les entrées (maxTextRecallSize)

À la fin de cet article, vous pouvez exécuter des requêtes hybrides qui combinent la recherche de mots clés et de vecteurs avec un classement sémantique facultatif.

Conditions préalables

• Un abonnement Azure. Créez-en un gratuitement.

• Un service Recherche Azure AI. Créer un service ou trouver un service existant.

• Index de recherche contenant des searchable champs vectoriels et non vecteurs. Nous vous recommandons l’Assistant Importation de données pour créer rapidement un index. Sinon, consultez Créer un index et ajouter des champs vectoriels à un index de recherche.

• Autorisations : Vous avez besoin d’un lecteur de données d’index de recherche pour interroger un index. Pour créer ou mettre à jour un index, vous avez besoin d’un contributeur de données d’index de recherche. Pour plus d’informations, consultez Se connecter à l’aide de rôles.

• (Facultatif) Installation du Kit de développement logiciel (SDK) :

  • Python : pip install azure-search-documents
  • C# : dotnet add package Azure.Search.Documents

• (Facultatif) Si vous souhaitez une conversion de texte en vecteur intégrée d’une chaîne de requête, créez et affectez un vectoriseur aux champs vectoriels dans l’index de recherche.

Choisir une API, un outil et un modèle utilisable

• L’Explorateur de recherche dans le portail Azure (prend en charge la syntaxe de recherche d’API stable et d’aperçu) a une vue JSON qui vous permet de coller une requête hybride.

• Packages stables ou en préversion plus récents de l’SDK Azure (consultez les journaux de modification pour la prise en charge des fonctionnalités du Kit de développement logiciel (SDK).

• API REST stables ou version récente de l’API en préversion si vous utilisez des fonctionnalités en préversion telles que maxTextRecallSize et countAndFacetMode (préversion).

  Pour une lisibilité, nous utilisons des exemples REST pour expliquer le fonctionnement des API. Vous pouvez utiliser un client REST comme Visual Studio Code avec l’extension REST pour générer des requêtes hybrides. Vous pouvez également utiliser le SDK Azure. Pour plus d’informations, consultez Démarrage rapide : Recherche vectorielle.

Modèles hybrides utilisables

Si vous débutez avec la recherche hybride, choisissez un modèle et ajustez-le en petites étapes. Ne commencez pas par le rappel vectoriel maximal, le rappel de texte volumineux et la reclassement sémantique dans la même requête.

• Hybride équilibré (par défaut) : utilisez-le pour la plupart des charges de travail. Commencez par k la plage de 30 à 50, top dans la plage de 10 à 20, et activez le classement sémantique uniquement lorsqu’il améliore la pertinence mesurée.

• Approche hybride « recall-first » : privilégiez cette option pour les requêtes complexes où la couverture constitue la priorité. Augmentez progressivement maxTextRecallSize et conservez les paramètres vectoriels modérés. Attendez-vous à un coût de fusion plus élevé.

• Hybride priorisant la précision : utilisez-le pour atteindre une faible latence à grande échelle. Conservez k et top modestes, appliquez des filtres sélectifs, et évitez les fonctionnalités sémantiques qui n'apportent pas de valeur ajoutée.

Quelles sont les raisons de la limitation des requêtes surchargées ?

Les requêtes hybrides exécutent le texte et la récupération de vecteurs en parallèle, puis fusionnent les résultats avec RRF. Si vous augmentez la contribution lexicale (par exemple, en modifiant la pondération hybride en faveur de BM25), vous augmentez le nombre de candidats texte qui doivent être fusionnés avec des candidats vectoriels. Si vous combinez cela avec des paramètres vectoriels coûteux et une reclassement sémantique, la pression du processeur et de la mémoire augmente rapidement.

Sur les configurations de capacité plus petites, ce travail de fusion et de reclassement supplémentaire peut entraîner :

• Pics de latence et p95/p99 plus élevés
• Réponses de limitation 429
• Les requêtes abandonnées ou expirées observées par le client lorsque le comportement de nouvelle tentative n’est pas configuré

Ajustez l’ordre avant d’envisager une mise à l’échelle

Paramétrez les paramètres de requête et de vecteur avant d’ajouter des réplicas :

1. Réduisez d’abord les paramètres de recherche vectorielle coûteux. Par exemple, si efSearch et maxConnections sont définis de manière agressive, réduisez-les avant le scale-out (par exemple, réduisez efSearch d’environ 800 à 128 à 192, et réduisez maxConnections de 64 à 32).
2. Limitez l’étendue de reclassement sémantique aux cas qui en bénéficient.
3. Retestez la latence et les taux 429 sous une charge représentative.
4. N’augmentez le nombre de répliques que si la limitation persiste après les ajustements.

Utilisez cette séquence pour améliorer la stabilité en premier et contrôler le coût avant de mettre à l’échelle.

Configurer une requête hybride

Cette section explique la structure de base d’une requête hybride et explique comment en configurer une dans l’Explorateur de recherche ou pour l’exécution dans un client REST.

Les résultats sont retournés en texte brut, y compris les vecteurs dans les champs marqués comme retrievable. Étant donné que les vecteurs numériques ne sont pas utiles dans les résultats de recherche, choisissez d’autres champs dans l’index en tant que proxy pour la correspondance vectorielle. Par exemple, si un index a des champs « descriptionVector » et « descriptionText », la requête peut correspondre à « descriptionVector », mais le résultat de la recherche peut afficher « descriptionText ». Utilisez le select paramètre pour spécifier uniquement les champs lisibles par l’homme dans les résultats.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-04-01
Content-Type: application/json
api-key: {{admin-api-key}}
{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "exhaustive": true,
            "k": 10
        },
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "exhaustive": true,
            "k": 10
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "select": "HotelName, Description, Address/City",
    "top": 10
}

import os
from azure.identity import DefaultAzureCredential
from azure.search.documents import SearchClient
from azure.search.documents.models import VectorizedQuery

# Set up the client
endpoint = os.environ["AZURE_SEARCH_ENDPOINT"]
index_name = "hotels-sample"
credential = DefaultAzureCredential()

client = SearchClient(endpoint=endpoint, index_name=index_name, credential=credential)

# Define your vector (typically from an embedding model)
query_vector = [-0.009154141, 0.018708462, ...]  # Your embedding values

# Create the vector query
vector_query = VectorizedQuery(
    vector=query_vector,
    k_nearest_neighbors=10,
    fields="DescriptionVector",
    exhaustive=True
)

# Execute hybrid search
results = client.search(
    search_text="historic hotel walk to restaurants and shopping",
    vector_queries=[vector_query],
    select=["HotelName", "Description", "Address/City"],
    top=10
)

for result in results:
    print(f"{result['HotelName']}: {result['Description']}")

using Azure;
using Azure.Identity;
using Azure.Search.Documents;
using Azure.Search.Documents.Models;

// Set up the client
string endpoint = Environment.GetEnvironmentVariable("AZURE_SEARCH_ENDPOINT");
string indexName = "hotels-sample";

SearchClient client = new SearchClient(
    new Uri(endpoint),
    indexName,
    new DefaultAzureCredential());

// Define your vector (typically from an embedding model)
float[] queryVector = new float[] { -0.009154141f, 0.018708462f, /* ... */ };

// Execute hybrid search
SearchResults<SearchDocument> results = client.Search<SearchDocument>(
    "historic hotel walk to restaurants and shopping",
    new SearchOptions
    {
        VectorSearch = new()
        {
            Queries = {
                new VectorizedQuery(queryVector)
                {
                    KNearestNeighborsCount = 10,
                    Fields = { "DescriptionVector" },
                    Exhaustive = true
                }
            }
        },
        Select = { "HotelName", "Description", "Address/City" },
        Size = 10
    });

await foreach (SearchResult<SearchDocument> result in results.GetResultsAsync())
{
    Console.WriteLine($"{result.Document["HotelName"]}: {result.Document["Description"]}");
}

Définir maxTextRecallSize et countAndFacetMode (version préliminaire)

Une requête hybride peut être paramétrée pour contrôler la quantité de chaque sous-requête qui contribue aux résultats combinés. Le paramètre maxTextRecallSize (version préliminaire) indique combien de résultats classés selon BM25 sont transmis au modèle de classement hybride.

Si votre demande inclut des facettes, utilisez des champs non-vecteurs marqués comme facetable dans l’index. Les champs vectoriels ne sont pas facetables.

Le nombre de facettes dépend du type de requête :

• Dans une requête texte seule, les facettes comptent les documents qui correspondent à la requête de texte.
• Dans une requête vectorielle uniquement, les facettes comptent les k documents retournés par la requête vectorielle.
• Dans une requête hybride, les facettes comptent à la fois pour les résultats vectoriels et texte. Le volet vectoriel fournit les k documents les plus proches. Le volet texte fournit des documents classés selon BM25. Le countAndFacetMode paramètre (préversion) détermine si les calculs de nombre et de facettes utilisent toutes les correspondances de texte ou uniquement les correspondances de texte récupérées pour le classement.

Si vous utilisez maxTextRecallSize, vous souhaiterez peut-être également définir countAndFacetMode. Ce paramètre détermine si count et facets inclut tous les documents correspondant à la requête de texte ou uniquement les documents récupérés dans la maxTextRecallSize fenêtre. La valeur par défaut est countAllResults.

Avec le mode par défaut countAllResults, les décomptes et les facettes peuvent inclure des documents du côté texte qui ne sont pas récupérés pour le classement RRF, car ils se trouvent en dehors de la fenêtre maxTextRecallSize. L’augmentation de maxTextRecallSize accroît le nombre de documents classés par BM25 disponibles pour le classement, mais n’augmente pas la contribution vectorielle au-delà de k. Utilisez countRetrievableResults si vous souhaitez que les calculs de comptage et de facette soient limités aux documents récupérés pour le classement hybride.

Nous vous recommandons la dernière préversion de l’API REST pour définir ces options.

1. Utilisez Search - POST (préversion) ou Search - GET (préversion) pour spécifier les paramètres d’aperçu.

2. Ajoutez un hybridSearch objet de paramètre de requête pour définir le nombre maximal de documents rappelés par le biais des résultats classés BM25 d’une requête hybride. Il a deux propriétés :

   • maxTextRecallSize spécifie le nombre de résultats classés par BM25 à fournir au classificateur « Reciprocal Rank Fusion » (RRF) utilisé dans les requêtes hybrides. La valeur par défaut est 1 000. Le maximum est de 10 000.

   • countAndFacetMode indique le nombre et la portée des facettes pour une requête hybride. La valeur par défaut, countAllResultsutilise le jeu de résultats hybride complet, y compris tous les documents qui correspondent à la requête de texte, même si certaines de ces correspondances de texte ne sont pas récupérées pour le classement RRF, car elles se trouvent en dehors de la maxTextRecallSize fenêtre. Utilisez countRetrievableResults pour limiter le décompte et les facettes aux documents récupérés pour le classement, y compris maxTextRecallSize les documents classés selon BM25 et les k correspondances vectorielles.

3. Définir maxTextRecallSize:

   • Diminuez maxTextRecallSize si la recherche de similarité vectorielle surpasse généralement la partie textuelle de la requête hybride.

   • Augmentez maxTextRecallSize si vous avez un index volumineux et que la valeur par défaut ne capture pas un nombre suffisant de résultats. Avec un jeu de résultats classé BM25 plus grand, vous pouvez définir top, skip et next pour également récupérer des parties de ces résultats.

Les exemples REST suivants montrent deux cas d’utilisation pour définir maxTextRecallSize.

Le premier exemple réduit maxTextRecallSize à 100, limitant le côté texte de la requête hybride à seulement 100 documents. Il définit countAndFacetMode également pour inclure uniquement les documents récupérables dans les calculs de nombre et de facette.

POST https://[service-name].search.windows.net/indexes/[index-name]/docs/search?api-version=2026-08-01-preview

    { 
      "vectorQueries": [ 
        { 
          "kind": "vector", 
          "vector": [1.0, 2.0, 3.0], 
          "fields": "my_vector_field", 
          "k": 10 
        } 
      ], 
      "search": "hello world", 
      "hybridSearch": { 
        "maxTextRecallSize": 100, 
        "countAndFacetMode": "countRetrievableResults" 
      } 
    } 

Le deuxième exemple porte maxTextRecallSize à 5 000. Il utilise également les commandes top, skip et next pour extraire des résultats à partir de jeux de données volumineux. Dans ce cas, la requête récupère les résultats classés par BM25 allant de la position 1 500 à 2 000 comme contribution de la requête textuelle à l’ensemble de résultats composite RRF.

POST https://[service-name].search.windows.net/indexes/[index-name]/docs/search?api-version=2026-08-01-preview

    { 
      "vectorQueries": [ 
        { 
          "kind": "vector", 
          "vector": [1.0, 2.0, 3.0], 
          "fields": "my_vector_field", 
          "k": 10 
        } 
      ], 
      "search": "hello world",
      "top": 500,
      "skip": 1500,
      "next": 500,
      "hybridSearch": { 
        "maxTextRecallSize": 5000, 
        "countAndFacetMode": "countRetrievableResults" 
      } 
    } 

Référence : hybridSearch | maxTextRecallSize | countAndFacetMode

Exemples de requêtes hybrides

Cette section contient plusieurs exemples de requêtes qui illustrent des modèles de requête hybrides.

Exemple : Recherche hybride avec filtre

Cet exemple ajoute un filtre, qui est appliqué aux filterable champs non-vecteurs de l’index de recherche.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-04-01
Content-Type: application/json
api-key: {{admin-api-key}}
{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "k": 10
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "vectorFilterMode": "preFilter",
    "filter": "ParkingIncluded",
    "top": "10"
}

Points clés :

• Les filtres sont appliqués au contenu des champs filtrables. Dans cet exemple, le champ ParkingIncluded est une valeur booléenne et elle est marquée comme filterable dans le schéma d’index.

• Dans les requêtes hybrides, les filtres peuvent être appliqués avant l’exécution de la requête pour réduire l’aire de requête ou après l’exécution de la requête pour réduire les résultats. "preFilter" est la valeur par défaut. Pour utiliser postFilter ou strictPostFilter (préversion), définissez le mode de traitement du filtre , comme illustré dans cet exemple.

• Lorsque vous appliquez un post-filtrage aux résultats de requête, le nombre de résultats peut être inférieur au top-n.

Référence : filter | vectorFilterMode

Exemple : Recherche hybride avec filtres ciblant des sous-requêtes vectorielles (préversion)

À l’aide de la dernière API REST en préversion, vous pouvez remplacer un filtre global sur la requête de recherche en appliquant un filtre secondaire qui cible uniquement les sous-requêtes vectorielles dans une requête hybride.

Cette fonctionnalité fournit un contrôle précis en garantissant que les filtres influencent uniquement les résultats de la recherche vectorielle, ce qui laisse les résultats de recherche basés sur des mots clés non affectés.

Le filtre ciblé remplace entièrement le filtre global, y compris les filtres utilisés pour la suppression de sécurité ou la recherche géospatiale. Dans les cas où des filtres globaux sont requis, tels que le découpage de sécurité, vous devez inclure explicitement ces filtres dans le filtre de niveau supérieur et dans chaque filtre de niveau vecteur pour garantir que la sécurité et d’autres contraintes sont appliquées de manière cohérente.

Pour appliquer des filtres vectoriels ciblés :

• Utilisez la version la plus récente de l'API REST de recherche de documents en aperçu ou un paquet bêta Kit de développement logiciel (SDK) Azure qui fournit la fonctionnalité.

• Modifiez une requête en y ajoutant un nouveau paramètre vectorQueries.filterOverride défini sur une expression de filtre OData .

Voici un exemple de requête hybride qui ajoute une substitution de filtre. Le filtre global « Rating gt 3 » est remplacé au moment de l’exécution par le filterOverride.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-08-01-preview

{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "exhaustive": true,
            "filterOverride": "Address/City eq 'Seattle'",
            "k": 10
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "select": "HotelName, Description, Address/City, Rating",
    "filter": "Rating gt 3",
    "debug": "vector",
    "top": 10
}

Exemple : Recherche hybride sémantique

En supposant que votre définition d’index inclut une configuration sémantique, vous pouvez formuler une requête qui inclut la recherche vectorielle et la recherche de mots clés, avec un classement sémantique sur le jeu de résultats fusionné. Si vous le souhaitez, vous pouvez ajouter des légendes et des réponses.

Chaque fois que vous utilisez le classement sémantique avec des vecteurs, assurez-vous k d’avoir la valeur 50. Le ranker sémantique utilise jusqu’à 50 correspondances comme entrée. La spécification de moins de 50 prive les modèles de classement sémantique des entrées nécessaires.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-04-01
Content-Type: application/json
api-key: {{admin-api-key}}
{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "k": 50
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "select": "HotelName, Description, Tags",
    "queryType": "semantic",
    "semanticConfiguration": "my-semantic-config",
    "captions": "extractive",
    "answers": "extractive",
    "top": "50"
}

Points clés :

• Le ranker sémantique accepte jusqu’à 50 résultats de la réponse fusionnée.

• « queryType » et « semanticConfiguration » sont requis.

• Les « légendes » et « réponses » sont facultatives. Les valeurs sont extraites du texte détaillé dans les résultats. Une réponse est retournée uniquement si les résultats incluent le contenu ayant les caractéristiques d’une réponse à la requête.

Référence : queryType | semanticConfiguration | captions | answers

Exemple : Recherche hybride sémantique avec filtre

Cet exemple ajoute un ParkingIncluded filtre à une requête hybride sémantique.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-04-01
Content-Type: application/json
api-key: {{admin-api-key}}
{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "k": 50
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "select": "HotelName, Description, Tags",
    "queryType": "semantic",
    "semanticConfiguration": "my-semantic-config",
    "captions": "extractive",
    "answers": "extractive",
    "filter": "ParkingIncluded",
    "vectorFilterMode": "preFilter",
    "top": "50"
}

Points clés :

• Le mode de filtre peut affecter le nombre de résultats disponibles pour le ranker sémantique. En guise de meilleure pratique, donnez au classement sémantique le nombre maximal de documents (50). Si les préfiltres ou les postfiltres sont trop sélectifs, vous risquez d’alimenter insuffisamment le ranker sémantique en lui donnant moins de 50 documents à traiter.

• preFilter est appliqué avant l’exécution de la requête. Si le préfiltrage réduit la zone de recherche à 100 documents, la requête vectorielle s’exécute sur le DescriptionVector champ pour ces 100 documents, en retournant les meilleures correspondances k=50. Ces 50 documents correspondants passent ensuite à RRF pour des résultats fusionnés, puis au classificateur sémantique.

• postFilter est appliqué après l’exécution de la requête. Si k=50 retourne 50 correspondances côté requête vectorielle, suivie d’un post-filtre appliqué aux 50 correspondances, vos résultats sont réduits par le nombre de documents qui répondent aux critères de filtre. Cela vous laisse moins de 50 documents à passer à l'outil de classement sémantique. Gardez cela à l’esprit si vous utilisez le classement sémantique. Le ranker sémantique fonctionne mieux s’il a 50 documents comme entrée.

• strictPostFilter (aperçu) est appliqué après l'exécution de la requête sur les meilleurs résultats non filtrésk. Il retourne toujours un nombre de documents inférieur ou égal à k. Si le k=50 non filtré retourne 50 résultats non filtrés et que le filtre correspond à 30 documents, seuls 30 documents sont retournés dans le jeu de résultats, même si l’index contient plus de 30 documents correspondant au filtre. Étant donné que ce mode a la plus grande réduction du rappel, nous vous déconseillons de l’utiliser avec le classement sémantique.

Configurer une réponse de requête

Lorsque vous configurez la requête hybride, réfléchissez à la structure de réponse. Le moteur de recherche classe les documents correspondants et retourne les résultats les plus pertinents. La réponse est un ensemble de lignes aplati. Les paramètres de la requête déterminent les champs qui se trouvent dans chaque ligne et le nombre de lignes dans la réponse.

Champs dans une réponse

Les résultats de la recherche sont composés de retrievable champs de votre index de recherche. Un résultat peut être soit :

• Tous les retrievable champs (une API REST par défaut).
• Champs explicitement répertoriés dans un select paramètre sur la requête.

Les exemples de cet article utilisaient une select instruction pour spécifier des champs de texte (non vecteur) dans la réponse.

Nombre de résultats

Une requête peut correspondre à un nombre quelconque de documents, autant que tous si les critères de recherche sont faibles (par exemple , « search=* » pour une requête Null). Étant donné qu’il est rarement pratique de retourner des résultats non liés, vous devez spécifier un maximum pour la réponse globale :

• "top": n résultats pour les requêtes par mot clé uniquement (aucun vecteur)
• "k": n résultats pour les requêtes vectorielles uniquement
• "top": n résultats pour les requêtes hybrides (avec ou sans sémantique) qui incluent un paramètre « search »

Les k et top sont facultatifs. Non spécifié, le nombre par défaut de résultats dans une réponse est 50. Vous pouvez définir top et skip pour parcourir plus de résultats ou modifier la valeur par défaut.

Résultats du classeur sémantique

Si vous utilisez le classificateur sémantique dans la version 2024-05-01-preview ou ultérieure, il est recommandé de définir k et maxTextRecallSize de manière à obtenir un total d’au moins 50. Vous pouvez ensuite restreindre les résultats retournés à l’utilisateur avec le top paramètre.

Si vous utilisez un ranker sémantique dans une version d’API antérieure à 2024-05-01-preview, procédez comme suit :

• Pour la recherche par mot clé uniquement (aucun vecteur) définie top sur 50
• Pour la recherche hybride, paramétrez k à 50 pour vous assurer que le classificateur sémantique obtient au moins 50 résultats.

Classement

Plusieurs ensembles sont créés pour les requêtes hybrides, avec ou sans le reranking sémantique optionnel. Le classement des résultats est calculé par fusion de classement réciproque (RRF).

Dans cette section, comparez les réponses entre la recherche à vecteur unique et la recherche hybride simple pour le résultat supérieur. Les différents algorithmes de classement, la métrique de similarité de HNSW et le RRF sont dans ce cas, produisent des scores qui ont des magnitudes différentes. Ce comportement est par conception. Les scores RRF peuvent paraître assez faibles, même en présence d’une forte correspondance de similarité. Les scores inférieurs sont une caractéristique de l’algorithme RRF. Dans une requête hybride avec RRF, une plus grande part des réciproques des documents classés est incluse dans les résultats, en raison du score relativement plus faible des documents classés par RRF, contrairement à une recherche vectorielle pure.

Recherche à vecteur unique : @search.score pour les résultats classés par similarité cosinus (fonction de distance de similarité de vecteur par défaut).

{
    "@search.score": 0.8399121,
    "HotelId": "49",
    "HotelName": "Swirling Currents Hotel",
    "Description": "Spacious rooms, glamorous suites and residences, rooftop pool, walking access to shopping, dining, entertainment and the city center.",
    "Category": "Luxury",
    "Address": {
    "City": "Arlington"
    }
}

Recherche hybride : @search.score pour les résultats hybrides classés à l’aide de la fusion de classement réciproque.

{
    "@search.score": 0.032786883413791656,
    "HotelId": "49",
    "HotelName": "Swirling Currents Hotel",
    "Description": "Spacious rooms, glamorous suites and residences, rooftop pool, walking access to shopping, dining, entertainment and the city center.",
    "Category": "Luxury",
    "Address": {
    "City": "Arlington"
    }
}

Résoudre les problèmes liés aux requêtes hybrides

Utilisez le tableau suivant pour diagnostiquer les problèmes courants liés aux requêtes hybrides.

Contenu connexe

• Vue d’ensemble de la recherche hybride
• Classement de la recherche hybride avec RRF
• Procédure de recherche vectorielle
• Classement sémantique
• Filtres de recherche vectorielle
• Passez en revue le code de démonstration vectoriel pour Python, C# ou JavaScript