Codage d'une expérience RAG AutoAI avec un magasin de vecteurs Milvus
Consultez les lignes directrices et les exemples de code pour apprendre à coder une expérience RAG AutoAI avec une base de données Milvus comme magasin de vecteurs.
Pour une solution RAG d'entreprise ou de production, configurez une base de données vectorielle à l'aide de Milvus. Le contenu vectorisé est conservé pour les futurs modèles et intégrations. Pour plus de détails, voir Travailler avec Milvus.
Les sections suivantes développent l'exemple de code annoté fourni avec le carnet de notes Automating RAG pattern with Milvus database.
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.
- Préparez les conditions préalables à la préparation des données et mettez en place l'expérience
- Configurer l'expérience RAG
- Exécution de l'expérimentation
- Examiner les modèles et sélectionner le meilleur
- Déployer le canevas
- Nettoyage (facultatif)
É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.
- Installer et importer les modules et dépendances nécessaires. Par exemple :
pip install 'ibm-watsonx-ai[rag]>=1.1.11'
pip install langchain-community==0.2.4
Si vous utilisez watsonx.data pour créer un magasin de vecteurs Milvus, vérifiez que vous disposez d' une instance watsonx.data.
Saisir les informations d'identification de la tâche. Voir Ajout d'informations d'identification pour les tâches.
watsonx.ai Runtime service. Voir Création de services.
Saisissez la clé API. Voir Gestion de la clé API de l'utilisateur.
Utilisez ce code pour initialiser le client. Par exemple :
from ibm_watsonx_ai import APIClient, Credentials
credentials = Credentials(
url = "https://us-south.ml.cloud.mydomain.com",
api_key = "***********"
)
client = APIClient(credentials)
Créez un projet ou un espace pour votre travail. Voir Créer un projet ou Créer un espace.
Obtenir l'identifiant du projet ou de l'espace. Voir Trouver l'identifiant du projet.
Définir un projet ou un espace par défaut :
client.set.default_project("<Project ID>")
client.set.default_space("<Space GUID>")
- Préparer les documents de mise à la terre
- Préparer les données d'évaluation
Documents de mise à la terre
Préparez et connectez les documents de mise à la terre que vous utilisez 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.
- AutoAI échantillonne les documentations pour l'exécution de 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) :
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)
input_data_references = [DataConnection(data_asset_id=asset_id)]
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/tree/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)]
Connexion à une base de données vectorielle Milvus
Cet extrait de code montre comment se connecter à une base de données vectorielle Milvus.
from ibm_watsonx_ai.helpers import DataConnection
milvus_data_source_type_id = client.connections.get_datasource_type_uid_by_name("milvus")
details = client.connections.create(
{
client.connections.ConfigurationMetaNames.NAME: "Milvus Connection",
client.connections.ConfigurationMetaNames.DATASOURCE_TYPE: milvus_data_source_type_id,
client.connections.ConfigurationMetaNames.PROPERTIES: {
"host": <PASTE MILVUS HOST HERE>,
"port": <PASTE MILVUS PORT HERE>,
"username": <PASTE MILVUS USERNAME HERE>,
"password": <PASTE MILVUS PASSWORD HERE>,
"ssl": True,
},
}
)
milvus_connection_id = client.connections.get_id(details)
vector_store_references = [DataConnection(connection_asset_id=milvus_connection_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. Les options de configuration disponibles sont les suivantes :
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 pertinentswindow 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 |
L'exemple de code suivant 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]
)
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, 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,
vector_store_references=vector_store_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.
best_pattern = rag_optimizer.get_pattern()
payload = {
client.deployments.ScoringMetaNames.INPUT_DATA: [
{
"values": ["How to use new approach of providing credentials to APIClient?"],
}
]
}
resp = best_pattern.query(payload)
print(resp["predictions"][0]["values"][0][0])
Réponse du modèle :
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.
Pour récupérer un motif spécifique, transmettez le nom du motif à rag_optimizer.get_pattern()
.
Étape 5 : Déployer un modèle
Après avoir testé un modèle localement, vous pouvez le déployer pour obtenir le point final et l'inclure dans les applications. Le déploiement s'effectue en stockant la fonction RAG définie, puis en créant un actif déployé. Pour plus d'informations sur les déploiements, voir Déploiement et gestion des ressources d'IA et Déploiements en ligne.
Pour créer le déploiement :
deployment_details = best_pattern.deploy(
name="AutoAI RAG deployment - ibm_watsonx_ai documentataion",
space_id=space_id
)
Récupère l'identifiant de déploiement de l'actif déployé.
deployment_id = client.deployments.get_id(deployment_details)
deployment_scoring_href = client.deployments.get_scoring_href(deployment_details)
print(deployment_scoring_href)
Le service RAG est maintenant déployé dans un espace et peut être testé.
Test du modèle déployé
Cet exemple de code montre comment tester la solution déployée. Saisissez les questions du test dans le fichier utile, en utilisant le format suivant :
questions = ["How to use new approach of providing credentials to APIClient?"]
payload = {
client.deployments.ScoringMetaNames.INPUT_DATA: [
{
"values": questions,
"access_token": client.service_instance._get_token()
}
]
}
resp = client.deployments.score(deployment_id, payload)
print(resp["predictions"][0]["values"][0][0])
Réponse du modèle :
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.
Examen des résultats d'expériences dans 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 de Cloud Object Storage qui est liée à votre compte. Par défaut, les résultats sont enregistrés par ID de formation d'expérience dans le répertoire « default_autoai_rag_out
».
Les résultats sont organisés par modèle. Par exemple :
|-- Pattern1
| | -- evaluation_results.json
| | -- indexing_notebook.ipynb (Milvus)
| | -- inference_notebook.ipynb (Milvus)
|-- 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 fichier
indexing_notebook.ipynb
contient le code python pour la construction d'un index de base de données vectorielle. Il introduit des commandes pour la récupération des données, le découpage en morceaux et la création d'enchâssements. - Le
inference_notebook.ipynb
notebook se concentre sur l'extraction de passages pertinents d'une base de connaissances pour les requêtes des utilisateurs et sur la génération de réponses en introduisant les passages extraits dans un grand modèle de langage.
Vous pouvez consulter les carnets ou les exécuter en ajoutant des informations d'authentification.
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 des carnets d'inférence et d'indexation
Pour télécharger le cahier d'inférence spécifié à partir du service, utilisez get_inference_notebook()
. Si le nom du motif n'est pas renseigné, la méthode télécharge le bloc-notes correspondant au motif le mieux classé.
rag_optimizer.get_inference_notebook(pattern_name='Pattern3')
Étape 6 : Nettoyage (facultatif)
Si vous souhaitez retirer votre collection de la base de données vectorielle Milvus, utilisez le SDK python pour Milvus.
Pour trouver le nom de la collection, allez dans les détails du modèle et consultez le nom de l'index du magasin de vecteurs.
Par exemple :
from pymilvus import MilvusClient
password = "<YOUR APIKEY>"
user = "ibmlhapikey"
uri = f"https://<HOST>:<PORT_NUMBER>"
collection_name = "autoai_rag_5c74df6a_20250319124623"
client = MilvusClient(uri=uri, password=password, user=milvus_credentials["username"])
client.drop_collection(collection_name=collection_name)
Etapes suivantes
- Exécutez le cahier d'inférence avec de nouvelles questions pour utiliser le modèle RAG sélectionné.
- Utilisez les documents indexés de cette expérience dans le site Prompt Lab pour créer un modèle de fondation. Voir Utilisation d'un index AutoAI Rag pour dialoguer avec des documents.
Sujet parent: Automatisation d'un modèle RAG avec le AutoAI SDK