Améliorer les résultats de recherche grâce au réglage de la recherche

Un modèle de recherche réglé peut vous fournir des résultats de meilleure qualité que le modèle de recherche de base.

Le réglage de la recherche est particulièrement utile pour les requêtes propres à un secteur ou à une entreprise, qui sont moins bien traitées par les LLM généraux. Il peut être utilisé pour entraîner davantage le modèle de recherche.

Limites

L'optimisation de la recherche ne peut être appliquée qu'aux data stores non structurés.

À propos des données d'entraînement

Pour affiner un modèle de recherche, vous devez d'abord rassembler des données d'entraînement.

Les données d'entraînement doivent contenir les requêtes que vous pensez que vos utilisateurs finaux poseront, ainsi que des extraits de texte de 250 à 500 mots contenant les informations pertinentes nécessaires pour répondre à ces requêtes. Une requête peut être associée à plusieurs extraits, à condition que chacun d'eux contienne des informations qui répondent à la requête.

Les données d'entraînement doivent également contenir des extraits de texte qui ne sont pas associés à des requêtes, mais qui sont par ailleurs similaires aux réponses en termes de style et de longueur. Ces extraits sans requêtes associées fournissent des exemples négatifs aléatoires pour ajuster le modèle. Google vous recommande de fournir au moins 10 000 de ces extraits.

Voici quelques termes pour décrire les données d'entraînement que vous devrez fournir :

• Requêtes d'entraînement : requêtes que vos utilisateurs finaux sont susceptibles de poser. Veillez à vous concentrer sur les requêtes contenant des termes spécifiques à un domaine ou à une entreprise.

  Veuillez fournir au moins 100.

• Segments extractifs : les extraits (généralement plusieurs paragraphes) doivent être tirés mot pour mot des documents du data store. L'ensemble des documents du data store est appelé "corpus".

  Vous devez fournir deux types de segments extractifs :

  • Segments contenant les informations pertinentes nécessaires pour répondre aux requêtes d'entraînement. Il s'agit de segments qui correspondent positivement aux requêtes.

  • Segments qui ne sont associés à aucune requête d'entraînement. Ces segments sont utilisés comme négatifs aléatoires lors de l'ajustement du modèle.

  Une ou deux phrases ne sont pas suffisamment longues pour constituer un segment extractif. Le segment doit contenir suffisamment de contexte pour l'entraînement. Par exemple, en réponse à une requête telle que "qui a fondé Google", un court extrait tel que "Larry Page" est insuffisant. Pour obtenir des exemples de segments suffisamment longs, consultez le tableau ci-dessous.

  Fournissez au moins un segment extractif par requête et au moins 10 000 segments extractifs supplémentaires.

• Scores de pertinence : il s'agit d'entiers non négatifs qui estiment la pertinence du segment extractif par rapport à la requête. Vous devez fournir une valeur de score pour chaque paire requête/segment extractif. Un score de 0 signifie que le segment d'extraction n'est pas du tout pertinent par rapport à la requête. Un score supérieur à zéro indique une certaine pertinence. Pour une notation simple, Google recommande d'attribuer la valeur 1 à tous les segments pertinents et la valeur 0 à ceux qui ne le sont pas. Si vous souhaitez classer la pertinence, vous pouvez attribuer des scores de pertinence de 0 à 10 (par exemple), 10 pour les segments les plus pertinents et 0 pour les segments qui ne le sont pas du tout.

  Fournissez au moins 100 scores pertinents et, éventuellement, des scores non pertinents supplémentaires.

Exemples de paires requête/segment extractif

Le tableau suivant fournit quelques exemples de paires requête/segment extractif. Ces exemples généraux ont été extraits de Wikipédia. Toutefois, pour un réglage utile, vous devez fournir des documents provenant d'ensembles de données propriétaires contenant des informations spécifiques à votre entreprise et moins facilement trouvables sur le Web.

La dernière paire de ce tableau est un exemple de paire avec un score de zéro, où la réponse n'est pas pertinente par rapport à la requête.

À propos des tests

Une fois l'entraînement terminé, la recherche optimisée est testée pour déterminer si l'optimisation a amélioré les résultats. Vous pouvez fournir explicitement les requêtes que vous souhaitez tester. Si vous ne fournissez pas de requêtes de test, Vertex AI Search utilise 20 % des requêtes d'entraînement comme requêtes de test.

Fichiers d'entraînement

Les données d'entraînement doivent être importées dans trois (ou quatre) fichiers spécifiques :

• Un fichier de corpus contenant les segments extractifs

• Un fichier de requête contenant uniquement les requêtes

• Un fichier d'étiquettes d'entraînement qui associe les requêtes aux segments et contient les scores de pertinence

• Facultatif : un fichier d'étiquettes de test semblable aux fichiers d'étiquettes d'entraînement, mais utilisé pour évaluer le modèle ajusté au lieu de l'entraîner

Les trois fichiers d'entraînement (fichier corpus, fichier de requête et fichier d'étiquettes d'entraînement) et le fichier d'étiquettes de test (facultatif) doivent se trouver dans Cloud Storage. Les chemins d'accès aux fichiers sont définis par des champs dans l'appel trainCustomMethod.

Fichier de corpus

Le fichier de corpus contient des segments extractifs : des segments contenant des informations permettant de répondre aux requêtes du fichier de requêtes et de nombreux segments supplémentaires à utiliser comme négatifs aléatoires lors de l'ajustement du modèle. Vous devez disposer d'au moins 100 segments contenant des réponses aux requêtes. Plusieurs segments peuvent répondre à une même requête. Vous devez également disposer d'au moins 10 000 segments aléatoires.

Si les documents de votre data store contiennent moins de 500 mots, vous pouvez les utiliser entiers comme segments. Sinon, créez de manière programmatique des segments aléatoires de 250 à 500 mots à partir des documents de votre data store et ajoutez-les au fichier corpus.

Le fichier de corpus est un fichier JSONL (JSON Lines) dans lequel chaque ligne contient les champs _id et text avec des valeurs de chaîne. Exemple :

  {"_id": "doc1", "text": "Google was founded on September 4, 1998, by American computer scientists Larry Page and Sergey Brin while they were PhD students at Stanford University in California. Together they own about 14% of its publicly listed shares and control 56% of its stockholder voting power through super-voting stock. The company went public via an initial public offering (IPO) in 2004. In 2015, Google was reorganized as a wholly owned subsidiary of Alphabet Inc. Google is Alphabet's largest subsidiary and is a holding company for Alphabet's internet properties and interests. Sundar Pichai was appointed CEO of Google on October 24, 2015, replacing Larry Page, who became the CEO of Alphabet. On December 3, 2019, Pichai also became the CEO of Alphabet. [...] On the list of most valuable brands, Google is 105 ranked second by Forbes and fourth by Interbrand."}
  {"_id": "doc2", "text": "Oxygenated blood leaves the lungs through pulmonary veins, which return it to the left part of the heart, completing the pulmonary cycle. This blood then enters the left atrium, which pumps it through the mitral valve into the left ventricle. From the left ventricle, the blood passes through the aortic valve to the aorta. The blood is then distributed to the body through the systemic circulation before returning again to the pulmonary circulation. Arteries Main article: Pulmonary artery From the right ventricle, blood is pumped through the semilunar pulmonary valve into the left and right main pulmonary artery (one for each lung), which branch into smaller pulmonary arteries that spread throughout the lungs. [...] Cardiac shunt is an unnatural connection between parts of the heart that leads to blood flow that bypasses the lungs."}
  {"_id": "doc3", "text": "The World Bowling Writers ( WBW ) International Bowling Hall of Fame was established in 1993 and is located in the International Bowling Museum and Hall of Fame , on the International Bowling Campus in Arlington , Texas. History The International Bowling Museum and Hall of Fame was located at 11 Stadium Plaza, St. Louis, Missouri, USA, and shared the same building with the St. Louis Cardinals Hall of Fame Museum, until November 8, 2008. It moved to Arlington and reopened in early 2010. In 2012, the WBW was merged with the International Bowling Media Association. After the merger, the WBW Hall of Fame inductees became part of the IBMA Luby Hall of Fame.  officers of the World Bowling Writers, which formed the Hall's Board.][...] The man and woman who receive the most votes are elected."}
  {"_id": "doc4", "text": "A \"Hello, World!\" program is generally a simple computer program which outputs (or displays) to the screen (often the console) a message similar to "Hello, World!" while ignoring any user input. A small piece of code in most general-purpose programming languages, this program is used to illustrate a language's basic syntax. A "Hello, World!" program is often the first written by a student of a new programming language, but such a program can also be used as a check to ensure that the computer software intended to compile or run source code is correctly installed, and that its operator understands how to use it.  [...] The C-language version was preceded by Kernighan's own 1972 A Tutorial Introduction to the Language B, where the first known version of the program is found in an example used to illustrate external variables."}

La taille maximale du fichier est de 500 000 lignes.

Fichier de requête

Le fichier de requête contient les exemples de requêtes qui seront utilisés pour ajuster le modèle. Chaque requête doit comporter un ou plusieurs segments extractifs correspondants dans le fichier du corpus. Vous devez fournir au moins 100 requêtes avec correspondance positive. Vous pouvez également fournir des requêtes non pertinentes, c'est-à-dire des requêtes qui correspondent à des segments extractifs avec un score de pertinence nul.

Le fichier de requête est au format JSONL et contient les mêmes champs que le fichier de corpus.

Exemple :

  {"_id": "query1", "text": "who founded Google?"}
  {"_id": "query2", "text": "where is blood pumped after it leaves the right ventricle?"}
  {"_id": "query3", "text": "where is the bowling hall of fame located?"}
  {"_id": "query4", "text": "why is the sky blue?"}

Le nombre maximal de requêtes autorisées dans le fichier est de 40 000.

Libellés d'entraînement

Le fichier d'étiquettes d'entraînement associe les requêtes aux segments extractifs et attribue un score à chaque paire requête/segment.

Si le fichier d'étiquettes de test n'est pas présent, 20 % des requêtes du fichier d'étiquettes d'entraînement sont réservées à l'évaluation du modèle ajusté après l'entraînement.

Le fichier contient l'ID d'une requête, l'ID du segment extractif correspondant (ou non) et un score indiquant la pertinence du segment par rapport à la requête. Il doit y avoir au moins une ligne par requête. Si une requête est traitée par deux segments, il y aura deux lignes pour cette requête. Score est une valeur entière non négative. Tout score supérieur à zéro indique que le document est lié à la requête. Plus le nombre est élevé, plus le niveau de pertinence est élevé. Si le score est omis, la valeur par défaut est 1.

Le fichier d'étiquettes d'entraînement est un fichier TSV (valeurs séparées par des tabulations) avec un en-tête. Le fichier doit contenir les colonnes query-id, corpus-id et score. query-id est une chaîne correspondant à la clé _id du fichier de requête, et corpus-id est une chaîne correspondant à _id dans le fichier de corpus.

Exemple :

query-id    corpus-id   score
query1  doc1    1
query2  doc2    1
query3  doc3    1
query3  doc9    1
query4  doc4    0

Le fichier d'étiquettes d'entraînement doit inclure au moins 100 ID de requête uniques. Le nombre d'ID de requête dans le fichier d'étiquettes d'entraînement combiné au nombre de requêtes dans le fichier d'étiquettes de test doit être inférieur à 500 000.

Libellés de test

Comme le fichier de libellés d'entraînement, ce fichier facultatif contient les ID de la requête et du segment extractif, ainsi que les scores de pertinence. Il contient moins de requêtes et des requêtes différentes de celles du fichier de libellés d'entraînement. Si elles sont présentes, les paires requête/segment extractif du fichier sont utilisées pour évaluer l'ajustement. Si le fichier d'étiquettes de test n'est pas présent, les paires requête/segment extractif du fichier d'étiquettes d'entraînement sont utilisées pour l'évaluation.

Ce fichier a le même format que le fichier des libellés d'entraînement.

Exemple :

query-id    corpus-id   score
query200    doc200  1
query201    doc201  1
query202    doc202  1

Bien que le fichier d'étiquettes de test soit facultatif, si vous le fournissez, il doit contenir au moins trois ID de requête uniques.

Avant de commencer

Activez les fonctionnalités de l'édition Enterprise pour l'application.

Affiner la recherche

Pour ajuster un modèle de recherche avec vos propres données d'entraînement, procédez comme suit.

from google.api_core.client_options import ClientOptions
from google.api_core.operation import Operation
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"
# corpus_data_path = "gs://my-bucket/corpus.jsonl"
# query_data_path = "gs://my-bucket/query.jsonl"
# train_data_path = "gs://my-bucket/train.tsv"
# test_data_path = "gs://my-bucket/test.tsv"


def train_custom_model_sample(
    project_id: str,
    location: str,
    data_store_id: str,
    corpus_data_path: str,
    query_data_path: str,
    train_data_path: str,
    test_data_path: str,
) -> Operation:
    #  For more information, refer to:
    # https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
    client_options = (
        ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
        if location != "global"
        else None
    )
    # Create a client
    client = discoveryengine.SearchTuningServiceClient(client_options=client_options)

    # The full resource name of the data store
    data_store = f"projects/{project_id}/locations/{location}/collections/default_collection/dataStores/{data_store_id}"

    # Make the request
    operation = client.train_custom_model(
        request=discoveryengine.TrainCustomModelRequest(
            gcs_training_input=discoveryengine.TrainCustomModelRequest.GcsTrainingInput(
                corpus_data_path=corpus_data_path,
                query_data_path=query_data_path,
                train_data_path=train_data_path,
                test_data_path=test_data_path,
            ),
            data_store=data_store,
            model_type="search-tuning",
        )
    )

    # Optional: Wait for training to complete
    # print(f"Waiting for operation to complete: {operation.operation.name}")
    # response = operation.result()

    # After the operation is complete,
    # get information from operation metadata
    # metadata = discoveryengine.TrainCustomModelMetadata(operation.metadata)

    # Handle the response
    # print(response)
    # print(metadata)
    print(operation)

    return operation

Tester la recherche optimisée et l'utiliser pour des requêtes de recherche individuelles

Une fois le réglage terminé, vous pouvez le tester en comparant les résultats des requêtes avec le modèle réglé et les résultats des mêmes requêtes avec le modèle de base.

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine_v1 as discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION"          # Values: "global", "us", "eu"
# engine_id = "YOUR_APP_ID"
# search_query = "YOUR_SEARCH_QUERY"


def search_sample(
    project_id: str,
    location: str,
    engine_id: str,
    search_query: str,
) -> discoveryengine.services.search_service.pagers.SearchPager:
    #  For more information, refer to:
    # https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
    client_options = (
        ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
        if location != "global"
        else None
    )

    # Create a client
    client = discoveryengine.SearchServiceClient(client_options=client_options)

    # The full resource name of the search app serving config
    serving_config = f"projects/{project_id}/locations/{location}/collections/default_collection/engines/{engine_id}/servingConfigs/default_config"

    # Optional - only supported for unstructured data: Configuration options for search.
    # Refer to the `ContentSearchSpec` reference for all supported fields:
    # https://cloud.google.com/python/docs/reference/discoveryengine/latest/google.cloud.discoveryengine_v1.types.SearchRequest.ContentSearchSpec
    content_search_spec = discoveryengine.SearchRequest.ContentSearchSpec(
        # For information about snippets, refer to:
        # https://cloud.google.com/generative-ai-app-builder/docs/snippets
        snippet_spec=discoveryengine.SearchRequest.ContentSearchSpec.SnippetSpec(
            return_snippet=True
        ),
        # For information about search summaries, refer to:
        # https://cloud.google.com/generative-ai-app-builder/docs/get-search-summaries
        summary_spec=discoveryengine.SearchRequest.ContentSearchSpec.SummarySpec(
            summary_result_count=5,
            include_citations=True,
            ignore_adversarial_query=True,
            ignore_non_summary_seeking_query=True,
            model_prompt_spec=discoveryengine.SearchRequest.ContentSearchSpec.SummarySpec.ModelPromptSpec(
                preamble="YOUR_CUSTOM_PROMPT"
            ),
            model_spec=discoveryengine.SearchRequest.ContentSearchSpec.SummarySpec.ModelSpec(
                version="stable",
            ),
        ),
    )

    # Refer to the `SearchRequest` reference for all supported fields:
    # https://cloud.google.com/python/docs/reference/discoveryengine/latest/google.cloud.discoveryengine_v1.types.SearchRequest
    request = discoveryengine.SearchRequest(
        serving_config=serving_config,
        query=search_query,
        page_size=10,
        content_search_spec=content_search_spec,
        query_expansion_spec=discoveryengine.SearchRequest.QueryExpansionSpec(
            condition=discoveryengine.SearchRequest.QueryExpansionSpec.Condition.AUTO,
        ),
        spell_correction_spec=discoveryengine.SearchRequest.SpellCorrectionSpec(
            mode=discoveryengine.SearchRequest.SpellCorrectionSpec.Mode.AUTO
        ),
        # Optional: Use fine-tuned model for this request
        # custom_fine_tuning_spec=discoveryengine.CustomFineTuningSpec(
        #     enable_search_adaptor=True
        # ),
    )

    page_result = client.search(request)

    # Handle the response
    for response in page_result:
        print(response)

    return page_result

Activer la recherche optimisée

Après avoir testé la recherche optimisée et décidé de l'utiliser pour toutes les requêtes de recherche, vous pouvez en faire le modèle de recherche par défaut.

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine_v1alpha as discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# engine_id = "YOUR_DATA_STORE_ID"


def update_serving_config_sample(
    project_id: str,
    location: str,
    engine_id: str,
) -> discoveryengine.ServingConfig:
    #  For more information, refer to:
    # https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
    client_options = (
        ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
        if location != "global"
        else None
    )
    # Create a client
    client = discoveryengine.ServingConfigServiceClient(client_options=client_options)

    # The full resource name of the serving config
    serving_config_name = f"projects/{project_id}/locations/{location}/collections/default_collection/engines/{engine_id}/servingConfigs/default_search"

    update_mask = "customFineTuningSpec.enableSearchAdaptor"

    serving_config = client.update_serving_config(
        request=discoveryengine.UpdateServingConfigRequest(
            serving_config=discoveryengine.ServingConfig(
                name=serving_config_name,
                custom_fine_tuning_spec=discoveryengine.CustomFineTuningSpec(
                    enable_search_adaptor=True  # Switch to `False` to disable tuned model
                ),
            ),
            update_mask=update_mask,
        )
    )

    # Handle the response
    print(serving_config)

    return serving_config

Désactiver la recherche optimisée

Si vous ne souhaitez plus utiliser la version optimisée de la recherche (par exemple, si vous trouvez que les résultats ne sont pas meilleurs, voire pires, qu'avant l'optimisation), vous pouvez la désactiver.

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine_v1alpha as discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# engine_id = "YOUR_DATA_STORE_ID"


def update_serving_config_sample(
    project_id: str,
    location: str,
    engine_id: str,
) -> discoveryengine.ServingConfig:
    #  For more information, refer to:
    # https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
    client_options = (
        ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
        if location != "global"
        else None
    )
    # Create a client
    client = discoveryengine.ServingConfigServiceClient(client_options=client_options)

    # The full resource name of the serving config
    serving_config_name = f"projects/{project_id}/locations/{location}/collections/default_collection/engines/{engine_id}/servingConfigs/default_search"

    update_mask = "customFineTuningSpec.enableSearchAdaptor"

    serving_config = client.update_serving_config(
        request=discoveryengine.UpdateServingConfigRequest(
            serving_config=discoveryengine.ServingConfig(
                name=serving_config_name,
                custom_fine_tuning_spec=discoveryengine.CustomFineTuningSpec(
                    enable_search_adaptor=True  # Switch to `False` to disable tuned model
                ),
            ),
            update_mask=update_mask,
        )
    )

    # Handle the response
    print(serving_config)

    return serving_config

Étapes suivantes

• Pour comprendre l'impact du réglage de la recherche sur la qualité de la recherche, évaluez la qualité de la recherche. Pour en savoir plus, consultez Évaluer la qualité de la recherche.