Codifica di un esperimento RAG AutoAI con estrazione del testo

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
  

  • Aggiungere le credenziali dell'attività. Vedere Aggiunta delle credenziali dell'attività.
  • Aggiungere il servizio watsonx.ai Runtime. Vedere Creazione di servizi.
  • Inserite la vostra chiave API. Vedere Gestione della chiave API utente.

• Utilizzare le proprie credenziali 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 Ricerca dell'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

benchmarking_data = [
     {
        "question": "What are the two main variants of Granite Code models?",
        "correct_answer": "The two main variants are Granite Code Base and Granite Code Instruct.",
        "correct_answer_document_ids": <TEXT EXTRACTION OUTPUT FILENAME>
     },
     {
        "question": "What is the purpose of Granite Code Instruct models?",
        "correct_answer": "Granite Code Instruct models are finetuned for instruction-following tasks using datasets like CommitPack, OASST, HelpSteer, and synthetic code instruction datasets, aiming to improve reasoning and instruction-following capabilities.",
        "correct_answer_document_ids": <TEXT EXTRACTION OUTPUT FILENAME>
     },
     {
        "question": "What is the licensing model for Granite Code models?",
        "correct_answer": "Granite Code models are released under the Apache 2.0 license, ensuring permissive and enterprise-friendly usage.",
        "correct_answer_document_ids": <TEXT EXTRACTION OUTPUT FILENAME>
     },
]

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

Fase 2: Elaborazione dei documenti di input con l'estrazione del testo

1. Inizializzare il servizio di estrazione del testo.

   from ibm_watsonx_ai.foundation_models.extractions import TextExtractions
   
   extraction = TextExtractions(
       credentials=credentials,
       space_id=<Space GUID>,
   )
   

2. Eseguire il lavoro di estrazione del testo.

   from ibm_watsonx_ai.metanames import TextExtractionsMetaNames
   
   response = extraction.run_job(
       document_reference=input_data_reference,
       results_reference=result_data_reference,
       steps={
           TextExtractionsMetaNames.OCR: {
               "process_image": True,
               "languages_list": ["en"],
           },
           TextExtractionsMetaNames.TABLE_PROCESSING: {"enabled": True},
       },
       results_format="markdown",
   )
   
   job_id = response['metadata']['id']
   

3. Ottenere i dettagli del lavoro.

   extraction.get_job_details(job_id)
   

4. Quando lo stato è completed, passare al passo successivo.

Fase 3: Configurazione dell'ottimizzatore RAG

L'oggetto rag_optimizer fornisce una serie 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:

Questo codice di esempio mostra le opzioni di configurazione per l'esecuzione dell'esperimento con la documentazione dell'SDK ibm- watsonx -ai:

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 4: esecuzione dell'esperimento

Eseguire l'ottimizzatore per creare i modelli RAG utilizzando le opzioni di configurazione specificate. Utilizzate il risultato dell'estrazione del testo come input per il vostro esperimento AutoAI RAG.

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 background_mode in True.

input_data_references = [result_data_reference]

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

Fase 5: Esaminare i modelli e selezionare il migliore

Dopo che l'esperimento AutoAI RAG è stato completato con successo, è possibile rivedere i modelli. Utilizzate il metodo summary per elencare i modelli completati e le informazioni sulle metriche di valutazione sotto forma di Pandas DataFrame in modo da poter rivedere 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:

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)

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

best_pattern.query(payload)

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.

Esaminare i risultati degli esperimenti in Cloud Object Storage

Se lo stato finale dell'esperimento è fallito o errato, utilizzare rag_optimizer.get_logs() o fare riferimento ai risultati dell'esperimento per capire cosa è andato storto. I risultati degli esperimenti e i registri vengono memorizzati nell'istanza predefinita di Cloud Object Storage collegata al vostro 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 sito indexing_inference_notebook.ipynb contiene il codice Python per la costruzione di un indice di database vettoriale e per la creazione di funzioni 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.

rag_optimizer.get_inference_notebook(pattern_name='Pattern3')