Codifica di un esperimento RAG AutoAI con un archivio vettoriale Milvus
Esaminate le linee guida e gli esempi di codice per imparare a codificare un esperimento RAG AutoAI con un database Milvus come archivio di vettori.
Per una soluzione RAG aziendale o di produzione, impostare un database vettoriale con Milvus. Il contenuto vettoriale persiste per modelli e integrazioni future. Per ulteriori informazioni, vedere Lavorare con Milvus.
Le sezioni seguenti approfondiscono il codice di esempio annotato fornito con il notebook Automazione del pattern RAG con il database Milvus.
Il notebook utilizza la libreria client watsonx.ai Python (versione 1.1.11 o successiva).
Seguite questi passaggi per codificare un esperimento RAG AutoAI per il vostro caso d'uso.
- Preparare i prerequisiti per la preparazione dei dati e impostare l'esperimento
- Configurare l'esperimento RAG
- Eseguire l'esperimento
- Esaminare i modelli e selezionare il migliore
- Distribuire lo schema
- Pulizia (facoltativa)
Fase 1: Preparare i prerequisiti per la preparazione dei dati e impostare l'esperimento
Preparare i prerequisiti per l'esperimento.
- Installare e importare i moduli e le dipendenze necessarie. Ad esempio:
pip install 'ibm-watsonx-ai[rag]>=1.1.11'
pip install langchain-community==0.2.4
Se si utilizza watsonx.data per creare un archivio vettoriale Milvus, verificare di avere un'istanza di watsonx.data.
Immettere le credenziali dell'attività. Vedere Aggiunta delle credenziali dell'attività.
watsonx.ai Servizio di runtime. Vedere Creazione di servizi.
Inserire la chiave API. Vedere Gestione della chiave API utente.
Utilizzare questo codice per inizializzare il client. Ad esempio:
from ibm_watsonx_ai import APIClient, Credentials
credentials = Credentials(
url = "https://us-south.ml.cloud.mydomain.com",
api_key = "***********"
)
client = APIClient(credentials)
Create un progetto o uno spazio per il vostro lavoro. Vedere Creazione di un progetto o Creazione di uno spazio.
Ottenere l'ID del progetto o dello spazio. Vedere Trovare l'ID del progetto.
Impostare un progetto o uno spazio predefinito:
client.set.default_project("<Project ID>")
client.set.default_space("<Space GUID>")
- Preparare i documenti di messa a terra
- Preparare i dati della valutazione
Documenti di messa a terra
Preparare e collegare i documenti di messa a terra utilizzati per eseguire l'esperimento RAG. Per ulteriori informazioni, vedere Acquisizione e preparazione dei dati in un progetto.
- Formati supportati: PDF, HTML, DOCX, Markdown, testo semplice
- Collegatevi ai dati in un bucket Cloud Object Storage, a una cartella in un bucket o specificate fino a 20 file.
- AutoAI campiona le documentazioni per l'esecuzione dell'esperimento
Ad esempio, per creare una connessione dati quando i documenti sono archiviati in un bucket Cloud Object Storage:
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'esempio seguente mostra come utilizzare la risorsa dati creata nel progetto (o promossa nello spazio):
core_api.html
è un esempio di file di documento di messa a terra utilizzato nei quaderni di esempio.
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
supporta fino a 20 istanze DataConnection
.
Dati di valutazione
I dati di valutazione devono essere in formato JSON con uno schema fisso con questi campi: question
, correct_answer
, correct_answer_document_ids
Ad esempio:
[
{
"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"
]
}
]
Preparare i dati di valutazione:
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)]
Connessione a un database di vettori Milvus
Questo frammento di codice mostra come connettersi a un database di vettori 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)]
Passo 2: Configurazione dell'ottimizzatore RAG
L'oggetto rag_optimizer
fornisce un insieme di metodi per lavorare con l'esperimento AutoAI RAG. In questa fase si inseriscono i dettagli per definire l'esperimento. Le opzioni di configurazione disponibili sono le seguenti:
Parametro | Descrizione | Valori |
---|---|---|
nome | Immettere un nome valido | Nome esperimento |
descrizione | Descrizione esperimento | Descrivere facoltativamente l'esperimento |
modelli_di_incorporazione | Incorporare modelli da provare | ibm/slate-125m-english-rtrvr intfloat/multilingual-e5-large |
metodi_di_recupero | Metodi di recupero da utilizzare | simple recupera e classifica tutti i documenti rilevantiwindow recupera e classifica un numero fisso di documenti rilevanti |
modelli_di_fondazione | Modelli di fondazione da provare | Vedere i modelli di Fondazione per attività |
numero_massimo_di_pattern_di_strappo | Numero massimo di modelli RAG da creare | 4-20 |
ottimizzazione_metrica | Nome della metrica da usare per l'ottimizzazione | faithfulness answer_correctness |
Il seguente codice di esempio mostra le opzioni di configurazione per l'esecuzione dell'esperimento con la documentazione dell'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]
)
Fase 3: esecuzione dell'esperimento
Eseguire l'ottimizzatore per creare i modelli RAG utilizzando le opzioni di configurazione specificate. In questo esempio di codice, il task viene eseguito in modalità interattiva. È possibile eseguire l'attività in background cambiando l'opzione background_mode
in 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
)
Fase 4: Esaminare i modelli e selezionare il migliore
Dopo che l'esperimento AutoAI RAG è stato completato con successo, è possibile rivedere i modelli. Usare il metodo 'summary
per elencare i modelli completati e le informazioni sulle metriche di valutazione sotto forma di un DataFrame Pandas, in modo da poter esaminare i modelli, classificati in base alle prestazioni rispetto alla metrica ottimizzata.
summary = rag_optimizer.summary()
summary
Ad esempio, i risultati dei modelli vengono visualizzati in questo modo:
Modello | correttezza_media_delle_risposte | media_fedeltà | correttezza_del_contesto | 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 | euclideo | finestra | 5 | meta-llama/llama-3-70b-instruct |
Pattern2 | 0.7172 | 0.5950 | 1.0000 | 1024 | intfloat/multilingual-e5-large | euclideo | finestra | 5 | ibm/granite-13b-chat-v2 |
Pattern3 | 0.6543 | 0.5144 | 1.0000 | 1024 | intfloat/multilingual-e5-large | euclideo | semplice | 5 | ibm/granite-13b-chat-v2 |
Pattern4 | 0.6216 | 0.5030 | 1.0000 | 1024 | intfloat/multilingual-e5-large | coseno | finestra | 5 | meta-llama/llama-3-70b-instruct |
Pattern5 | 0.7369 | 0.5630 | 1.0000 | 1024 | intfloat/multilingual-e5-large | coseno | finestra | 3 | mistralai/mixtral-8x7b-instruct-v01 |
Selezionare un modello da testare localmente
Il passo successivo consiste nel selezionare un modello e testarlo localmente.
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])
Risposta del modello:
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.
Per recuperare un modello specifico, passare il nome del modello a rag_optimizer.get_pattern()
.
Passo 5: distribuire un modello
Dopo aver testato un modello localmente, è possibile distribuirlo per ottenere l'endpoint e includerlo nelle applicazioni. La distribuzione avviene memorizzando la funzione RAG definita, quindi creando un asset distribuito. Per ulteriori informazioni sulle distribuzioni, vedere Distribuzione e gestione delle risorse AI e Distribuzioni online.
Per creare l'installazione client:
deployment_details = best_pattern.deploy(
name="AutoAI RAG deployment - ibm_watsonx_ai documentataion",
space_id=space_id
)
Recupera l'ID di distribuzione per la risorsa distribuita.
deployment_id = client.deployments.get_id(deployment_details)
deployment_scoring_href = client.deployments.get_scoring_href(deployment_details)
print(deployment_scoring_href)
Il servizio RAG è ora distribuito in uno spazio e disponibile per il test.
Verifica del modello distribuito
Questo esempio di codice mostra come testare la soluzione distribuita. Inserire le domande del test nel payload, utilizzando il seguente formato:
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])
Risposta del modello:
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.
Esame dei risultati degli esperimenti in Cloud Object Storage.
Se lo stato finale dell'esperimento è fallito o errore, utilizzare rag_optimizer.get_logs()
o fare riferimento ai risultati dell'esperimento per capire cosa è andato storto. I risultati degli esperimenti e i registri sono archiviati nell'istanza predefinita Cloud Object Storage collegata all'account. Per impostazione predefinita, i risultati vengono salvati con l'ID di formazione dell'esperimento nella directory " default_autoai_rag_out
".
I risultati sono organizzati per modello. Ad esempio:
|-- Pattern1
| | -- evaluation_results.json
| | -- indexing_notebook.ipynb (Milvus)
| | -- inference_notebook.ipynb (Milvus)
|-- Pattern2
| ...
|-- training_status.json
Ogni schema contiene questi risultati:
- Il file
evaluation_results.json
contiene i risultati della valutazione per ogni domanda di benchmark. - Il file
indexing_notebook.ipynb
contiene il codice python per la creazione di un indice del database vettoriale. Introduce i comandi per il recupero dei dati, il chunking e la creazione di embeddings. - Il notebook
inference_notebook.ipynb
si concentra sul recupero di brani rilevanti da una base di conoscenza per le interrogazioni dell'utente e sulla generazione di risposte inserendo i brani recuperati in un modello linguistico di grandi dimensioni.
È possibile rivedere i notebook o eseguirli aggiungendo le credenziali di autenticazione.
Il quaderno dei risultati indexing_notebook.ipynb
contiene il codice per incorporare e indicizzare i documenti. È possibile accelerare l'attività di indicizzazione dei documenti cambiando vector_store.add_documents()
con vector_store.add_documents_async()
.
Ottenere quaderni di inferenza e indicizzazione
Per scaricare il quaderno di inferenze specificato dal servizio, utilizzare get_inference_notebook()
. Se si lascia vuoto il nome del modello, il metodo scarica il blocco note per il modello di rango più alto.
rag_optimizer.get_inference_notebook(pattern_name='Pattern3')
Fase 6: pulizia (facoltativa)
Se si desidera rimuovere la propria collezione dal database dei vettori di Milvus, utilizzare l'SDK python per Milvus.
Per trovare il nome della collezione, andare ai dettagli del modello e vedere il nome dell'indice del negozio di vettori.
Ad esempio:
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)
Passi successivi
- Eseguire il quaderno delle inferenze con nuove domande per utilizzare il modello RAG selezionato.
- Utilizzate i documenti indicizzati di questo esperimento nel sito Prompt Lab per fondare i suggerimenti per un modello di fondazione. Vedere Utilizzo di un indice AutoAI Rag per chattare con i documenti.
Argomento principale: Automazione di un pattern RAG con l'SDK AutoAI