0 / 0
Retourner à la version anglaise de la documentation

Codage d'une expérience RAG AutoAI avec un magasin de vecteurs Chroma

Dernière mise à jour : 21 févr. 2025
Codage d'une expérience RAG AutoAI avec un magasin de vecteurs Chroma

Examinez les directives et les exemples de code pour apprendre à coder une expérience RAG AutoAI en utilisant la base de données Chroma par défaut, en mémoire, comme magasin de vecteurs.

Stockage du contenu vectoriel dans une base de données Chroma

Lorsque vous configurez votre expérience AutoAI RAG et que vous ne spécifiez pas de connexion à un magasin de vecteurs, le contenu vectorisé est enregistré dans la base de données Chroma par défaut, en mémoire. Le contenu ne persiste pas au-delà de l'expérience, il ne s'agit donc pas d'une méthode de production viable pour déployer un motif RAG. Cependant, il offre une voie rapide pour créer un modèle RAG.

Les sections suivantes développent l'exemple de code annoté fourni avec le Automatisation du modèle RAG avec la base de données Chroma notebook.

Le notebook utilise la bibliothèque client watsonx.ai Python (version 1.1.11 ou ultérieure).

Suivez les étapes suivantes pour coder une expérience RAG AutoAI pour votre cas d'utilisation.

  1. Préparez les conditions préalables à la préparation des données et mettez en place l'expérience
  2. Configurer l'expérience RAG
  3. Exécution de l'expérimentation
  4. Examiner les modèles et sélectionner le meilleur

Étape 1 : Préparer les conditions préalables à la préparation des données et mettre en place l'expérience

Préparer les conditions préalables à l'expérience.

client.set.default_project("<Project ID>")
client.set.default_space("<Space GUID>")

Documents de mise à la terre

Préparez et connectez les documents de mise à la terre que vous utiliserez pour réaliser l'expérience RAG. Pour plus de détails, voir L'obtention et la préparation des données dans un projet.

  • Formats pris en charge : PDF, HTML, DOCX, Markdown, texte brut
  • Connectez-vous aux données d'un Cloud Object Storage bucket, d'un dossier dans un bucket, ou spécifiez jusqu'à 20 fichiers.
  • LAutoAI utilise un échantillon de documents pour réaliser l'expérience

Par exemple, pour créer une connexion de données lorsque des documents sont stockés dans un Cloud Object Storage bucket :

from ibm_watsonx_ai.helpers import DataConnection, S3Location

conn_meta_props= {
    client.connections.ConfigurationMetaNames.NAME: f"Connection to input data - {datasource_name} ",
    client.connections.ConfigurationMetaNames.DATASOURCE_TYPE: client.connections.get_datasource_type_id_by_name(datasource_name),
    client.connections.ConfigurationMetaNames.DESCRIPTION: "ibm-watsonx-ai SDK documentation",
    client.connections.ConfigurationMetaNames.PROPERTIES: {
        'bucket': <BUCKET_NAME>,
        'access_key': <ACCESS_KEY>,
        'secret_key': <SECRET_ACCESS_KEY>,
        'iam_url': 'https://iam.cloud.ibm.com/identity/token',
        'url': <ENDPOINT_URL>
    }
}

conn_details = client.connections.create(meta_props=conn_meta_props)
cos_connection_id = client.connections.get_id(conn_details)

input_data_references = [DataConnection(
    connection_asset_id=cos_connection_id,
    location=S3Location(
        bucket=<BACKET_NAME>,
        path=<BACKET_PATH>
    )
)]

L'exemple suivant montre comment utiliser le bien de données créé dans le projet (ou promu dans l'espace).

Remarque :

core_api.html est un exemple de fichier de document de base utilisé dans les exemples de carnets.

import os, wget
from ibm_watsonx_ai.helpers import DataConnection

input_data_filename = "core_api.html"
input_data_path = f"https://ibm.github.io/watsonx-ai-python-sdk/{input_data_filename}"

if not os.path.isfile(input_data_filename): 
    wget.download(input_data_path, out=input_data_filename)
    
asset_details = client.data_assets.create(input_data_filename, input_data_filename)
asset_id = client.data_assets.get_id(asset_details)
asset_id

input_data_references = [DataConnection(data_asset_id=asset_id)]
Astuce :

input_data_references supporte jusqu'à 20 instances DataConnection.

Données d'évaluation

  • Les données d'évaluation doivent être au format JSON avec un schéma fixe comprenant les champs suivants : question, correct_answer, correct_answer_document_ids

Par exemple :

[
    {
        "question": "What is the purpose of get_token()?",
        "correct_answer": "get_token() is used to retrieve an authentication token for secure API access.",
        "correct_answer_document_ids": [
            "core_api.html"
        ]
    },
    {
        "question": "How does the delete_model() function operate?",
        "correct_answer": "delete_model() method allows users to delete models they've created or managed.",
        "correct_answer_document_ids": [
            "core_api.html"
        ]
    }
]

Préparer les données d'évaluation :

import os, wget
from ibm_watsonx_ai.helpers import DataConnection

test_data_filename = "benchmarking_data_core_api.json"
test_data_path = f"https://github.com/IBM/watsonx-ai-samples/blob/master/cloud/data/autoai_rag/{test_data_filename}"

if not os.path.isfile(test_data_filename): 
    wget.download(test_data_path, out=test_data_filename)

test_asset_details = client.data_assets.create(name=test_data_filename, file_path=test_data_filename)
test_asset_id = client.data_assets.get_id(test_asset_details)

test_data_references = [DataConnection(data_asset_id=test_asset_id)]

Étape 2 : Configuration de l'optimiseur RAG

L'objet rag_optimizer fournit un ensemble de méthodes pour travailler avec l'expérience RAG AutoAI. Dans cette étape, entrez les détails pour définir l'expérience. Voici les options de configuration disponibles :

Paramètre Descriptif Valeurs
nom Entrez un nom valide Nom de l'expérimentation
description Description de l'expérimentation Décrire éventuellement l'expérience
modèles d'intégration Intégrer des modèles à essayer ibm/slate-125m-english-rtrvr
intfloat/multilingual-e5-large
méthodes d'extraction Méthodes de recherche à utiliser simple recherche et classe tous les documents pertinents
window recherche et classe un nombre fixe de documents pertinents
modèles_de_fondation Modèles de fondations à essayer Voir les modèles de fondation par tâche
max_number_of_rag_patterns (nombre maximal de motifs de frottement) Nombre maximal de motifs RAG à créer 4-20
optimisation_métrie Nom(s) de la métrique à utiliser pour l'optimisation faithfulness
answer_correctness

Cet exemple de code montre les options de configuration pour exécuter l'expérience avec la documentation ibm-watsonx-ai SDK :

from ibm_watsonx_ai.experiment import AutoAI

experiment = AutoAI(credentials, project_id=project_id)

rag_optimizer = experiment.rag_optimizer(
    name='DEMO - AutoAI RAG ibm-watsonx-ai SDK documentation',
    description="AutoAI RAG experiment grounded with the ibm-watsonx-ai SDK documentation",
    max_number_of_rag_patterns=5,
    optimization_metrics=[AutoAI.RAGMetrics.ANSWER_CORRECTNESS]
)
Conseil: Vous pouvez modifier la configuration en utilisant les valeurs prises en charge décrites dans le tableau de configuration.
rag_optimizer = experiment.rag_optimizer(
    name='DEMO - AutoAI RAG ibm-watsonx-ai SDK documentation',
    description="AutoAI RAG experiment grounded with the ibm-watsonx-ai SDK documentation",
    embedding_models=["ibm/slate-125m-english-rtrvr"],
    foundation_models=["ibm/granite-13b-chat-v2","mistralai/mixtral-8x7b-instruct-v01"],
    max_number_of_rag_patterns=5,
    optimization_metrics=[AutoAI.RAGMetrics.ANSWER_CORRECTNESS]
)

Étape 3 : Exécuter l'expérience

Lancer l'optimiseur pour créer les modèles RAG en utilisant les options de configuration spécifiées. Dans cet exemple de code pour l'exécution d'une expérience Chroma, la tâche est exécutée en mode interactif. Vous pouvez exécuter la tâche en arrière-plan en changeant la valeur de background_mode en True.

run_details = rag_optimizer.run(
    input_data_references=input_data_references,
    test_data_references=test_data_references,
    background_mode=False
)

Étape 4 : Examiner les modèles et sélectionner le meilleur

Une fois que l'expérience AutoAI RAG s'est achevée avec succès, vous pouvez examiner les modèles. Utilisez la méthode " summary pour répertorier les modèles terminés et les informations sur les mesures d'évaluation sous la forme d'un DataFrame Pandas afin que vous puissiez examiner les modèles, classés en fonction de leur performance par rapport à la mesure optimisée.

summary = rag_optimizer.summary()
summary

Par exemple, les résultats du modèle s'affichent comme suit :

Schéma moyenne_des_réponses_correctes fidélité moyenne exactitude_du_contexte_moyen chunking.chunk_size embeddings.model_id vector_store.distance_metric retrieval.method retrieval.number_of_chunks generation.model_id
Pattern1 0.6802 0.5407 1.0000 512 ibm/slate-125m-english-rtrvr euclidien fenêtre 5 meta-llama/llama-3-70b-instruct
Pattern2 0.7172 0.5950 1.0000 1 024 intfloat/multilingual-e5-large euclidien fenêtre 5 ibm/granite-13b-chat-v2
Pattern3 0.6543 0.5144 1.0000 1 024 intfloat/multilingual-e5-large euclidien simples 5 ibm/granite-13b-chat-v2
Pattern4 0.6216 0.5030 1.0000 1 024 intfloat/multilingual-e5-large cosinus fenêtre 5 meta-llama/llama-3-70b-instruct
Pattern5 0.7369 0.5630 1.0000 1 024 intfloat/multilingual-e5-large cosinus fenêtre 3 mistralai/mixtral-8x7b-instruct-v01

Sélectionner un modèle à tester localement

L'étape suivante consiste à sélectionner un modèle et à le tester localement. Chroma étant en mémoire, vous devez recréer l'index des documents.

Astuce :

Dans l'exemple de code suivant, l'index est construit avec les documents core_api.html et fm_embeddings.html.

from langchain_community.document_loaders import WebBaseLoader

best_pattern = rag_optimizer.get_pattern()

urls = [
    "https://ibm.github.io/watsonx-ai-python-sdk/core_api.html",
    "https://ibm.github.io/watsonx-ai-python-sdk/fm_embeddings.html",
]
docs_list = WebBaseLoader(urls).load()
doc_splits = best_pattern.chunker.split_documents(docs_list)
best_pattern.indexing_function(doc_splits)

Interroger le modèle RAG localement.

payload = {
    client.deployments.ScoringMetaNames.INPUT_DATA: [
        {
            "values": ["How to use new approach of providing credentials to APIClient?"],
        }
    ]
}

best_pattern.query(payload)

La réponse du modèle se présente comme suit :

According to the document, the new approach to provide credentials to APIClient is by using the Credentials class. Here's an example:


from ibm_watsonx_ai import APIClient
from ibm_watsonx_ai import Credentials

credentials = Credentials(
                   url = "https://us-south.ml.cloud.ibm.com",
                   token = "***********",
                  )

client = APIClient(credentials)


This replaces the old approach of passing a dictionary with credentials to the APIClient constructor.
Astuce :

Pour récupérer un motif spécifique, transmettez le numéro du motif à rag_optimizer.get_pattern().

Examen des résultats d'expériences dans le Cloud Object Storage

Si l'état final de l'expérience est un échec ou une erreur, utilisez rag_optimizer.get_logs() ou reportez-vous aux résultats de l'expérience pour comprendre ce qui n'a pas fonctionné. Les résultats des expériences et les journaux sont stockés dans l'instance par défaut Cloud Object Storage liée à votre compte. Par défaut, les résultats sont enregistrés dans le répertoire default_autoai_rag_out.

Les résultats sont organisés par modèle. Par exemple :

|-- Pattern1
|      | -- evaluation_results.json
|      | -- indexing_inference_notebook.ipynb (Chroma)
|-- Pattern2
|    ...
|-- training_status.json

Chaque modèle contient ces résultats :

  • Le fichier evaluation_results.json contient les résultats de l'évaluation pour chaque question de référence.
  • Le indexing_inference_notebook.ipynb contient le code python pour la construction de l'index de la base de données vectorielle ainsi que pour la construction de la fonction de récupération et de génération. Le carnet de notes présente des commandes pour la récupération des données, la création de chunks et d'embeddings, ainsi que pour la récupération de chunks, la construction d'invites et la génération de réponses.
Remarque :

Le cahier des résultats indexing_notebook.ipynb contient le code d'intégration et d'indexation des documents. Vous pouvez accélérer l'indexation des documents en remplaçant vector_store.add_documents() par vector_store.add_documents_async().

Obtenir le carnet d'inférence et d'indexation

Pour télécharger un cahier d'inférence spécifique, utilisez le get_inference_notebook(). Si vous laissez pattern_name vide, la méthode télécharge le carnet du meilleur modèle calculé.

rag_optimizer.get_inference_notebook(pattern_name='Pattern3')

Sujet parent: Automatisation d'un modèle RAG avec le AutoAI SDK