0 / 0
Torna alla versione inglese della documentazione

Codifica di un esperimento AutoAI RAG con un archivio vettoriale Chroma

Ultimo aggiornamento: 21 feb 2025
Codifica di un esperimento AutoAI RAG con un archivio vettoriale Chroma

Esaminare le linee guida e gli esempi di codice per imparare a codificare un esperimento RAG AutoAI utilizzando il database Chroma predefinito e in memoria come archivio vettoriale.

Memorizzazione di contenuti vettoriali in un database Chroma

Quando si imposta l'esperimento AutoAI RAG e non si specifica una connessione a un archivio vettoriale, il contenuto vettoriale viene salvato nel database Chroma predefinito, in memoria. Il contenuto non persiste al di là dell'esperimento, quindi questo non è un metodo di produzione praticabile per distribuire un modello RAG. Tuttavia, fornisce un percorso rapido per la creazione di un modello RAG.

Le sezioni seguenti approfondiscono il codice di esempio annotato fornito con il quaderno Automazione del modello RAG con il database Chroma.

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.

  1. Preparare i prerequisiti per la preparazione dei dati e impostare l'esperimento
  2. Configurare l'esperimento RAG
  3. Eseguire l'esperimento
  4. Esaminare i modelli e selezionare il migliore

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
    
  • Utilizzarli 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>")

Documenti di messa a terra

Preparare e collegare i documenti di messa a terra che verranno 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 utilizza un campione di documenti per eseguire l'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).

Nota:

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)
asset_id

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

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/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)]

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. Queste sono le opzioni di configurazione disponibili:

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 rilevanti
window 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

Questo 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]
)
Suggerimento: È possibile modificare la configurazione utilizzando i valori supportati descritti nella tabella di configurazione.
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 per l'esecuzione di un esperimento Chroma, 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,
    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 è selezionare un modello e testarlo localmente. Poiché Chroma è in-memory, è necessario ricreare l'indice dei documenti.

Suggerimento:

Nel seguente esempio di codice, l'indice viene costruito con i documenti core_api.html e 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)

Interrogare il modello RAG a livello locale.

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

best_pattern.query(payload)

La risposta del modello è la seguente:

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.
Suggerimento:

Per recuperare un modello specifico, passare il numero del modello a rag_optimizer.get_pattern().

Esame dei risultati degli esperimenti nel 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 nella directory default_autoai_rag_out.

I risultati sono organizzati per modello. Ad esempio:

|-- Pattern1
|      | -- evaluation_results.json
|      | -- indexing_inference_notebook.ipynb (Chroma)
|-- 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_inference_notebook.ipynb contiene il codice python per la creazione dell'indice del database vettoriale e della funzione di recupero e generazione. Il quaderno introduce i comandi per il recupero dei dati, il chunking e la creazione di embeddings, nonché per il recupero di chunks, la costruzione di prompt e la generazione di risposte.
Nota:

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 il quaderno di inferenza e indicizzazione

Per scaricare un quaderno di inferenze specifico, utilizzare l'opzione get_inference_notebook(). Se si lascia pattern_name vuoto, il metodo scarica il blocco note del miglior modello calcolato.

rag_optimizer.get_inference_notebook(pattern_name='Pattern3')

Argomento principale: Automazione di un pattern RAG con l'SDK AutoAI