Codifica di un esperimento RAG AutoAI con un archivio vettoriale Milvus

Fase 1: Preparare i prerequisiti per la preparazione dei dati e impostare l'esperimento

Copy link to section

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
Copy to clipboardCopiato negli appunti

• 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)
Copy to clipboardCopiato negli appunti

• 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>")
Copy to clipboardCopiato negli appunti

client.set.default_space("<Space GUID>")
Copy to clipboardCopiato negli appunti

• Preparare i documenti di messa a terra
• Preparare i dati della valutazione

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>
    )
)]
Copy to clipboardCopiato negli appuntiShow more

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)]
Copy to clipboardCopiato negli appunti

[
    {
        "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"
        ]
    }
]
Copy to clipboardCopiato negli appunti

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)]
Copy to clipboardCopiato negli appunti

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)]
Copy to clipboardCopiato negli appuntiShow more

Passo 2: Configurazione dell'ottimizzatore RAG

Copy link to section

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:

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]
)
Copy to clipboardCopiato negli appunti

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]
)
Copy to clipboardCopiato negli appunti

Fase 3: esecuzione dell'esperimento

Copy link to section

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
)
Copy to clipboardCopiato negli appunti

Fase 4: Esaminare i modelli e selezionare il migliore

Copy link to section

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
Copy to clipboardCopiato negli appunti

Ad esempio, i risultati dei modelli vengono visualizzati in questo modo:

best_pattern = rag_optimizer.get_pattern()
Copy to clipboardCopiato negli appunti

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])
Copy to clipboardCopiato negli appunti

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.

Passo 5: distribuire un modello

Copy link to section

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
)
Copy to clipboardCopiato negli appunti

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)
Copy to clipboardCopiato negli appunti

Il servizio RAG è ora distribuito in uno spazio e disponibile per il test.

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])
Copy to clipboardCopiato negli appunti

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.

Copy link to section

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
Copy to clipboardCopiato negli appunti

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.

rag_optimizer.get_inference_notebook(pattern_name='Pattern3')
Copy to clipboardCopiato negli appunti

Fase 6: pulizia (facoltativa)

Copy link to section

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)
Copy to clipboardCopiato negli appunti

Passi successivi

Copy link to section

• 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