Codificación de un experimento RAG AutoAI con extracción de texto

Paso 1: Preparar los requisitos previos para preparar los datos y poner en marcha el experimento

Prepare los requisitos previos para el experimento.

• Instale e importe los módulos y dependencias necesarios. Por ejemplo:

  pip install 'ibm-watsonx-ai[rag]>=1.1.11'
  pip install langchain-community==0.2.4
  

  • Añadir credenciales de tareas. Véase Añadir credenciales de tarea.
  • Añada el servicio watsonx.ai Runtime. Véase Creación de servicios.
  • Introduzca su clave API. Véase Gestión de la clave API de usuario.

• Utilice sus credenciales para inicializar el cliente. Por ejemplo:

  from ibm_watsonx_ai import APIClient, Credentials
  
  credentials = Credentials(
                  url = "https://us-south.ml.cloud.mydomain.com",
                  api_key = "***********"
                  )
  
  client = APIClient(credentials)
  

• Crea un proyecto o espacio para tu trabajo. Véase Crear un proyecto o Crear un espacio.

• Obtiene el ID del proyecto o espacio. Véase Encontrar el ID del proyecto.

• Establece un proyecto o espacio por defecto:

client.set.default_project("<Project ID>")

client.set.default_space("<Space GUID>")

• Preparar los documentos de puesta a tierra
• Preparar los datos de evaluación

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

Paso 2: Procesar los documentos de entrada con extracción de texto

1. Inicializar el servicio de extracción de texto.

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

2. Ejecute el trabajo de extracción de texto.

   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. Obtenga detalles del trabajo.

   extraction.get_job_details(job_id)
   

4. Cuando el estado sea completed, pase al paso siguiente.

Paso 3: Configurar el optimizador RAG

El objeto rag_optimizer proporciona un conjunto de métodos para trabajar con el experimento AutoAI RAG. En este paso, introduzca los detalles para definir el experimento. Estas son las opciones de configuración disponibles:

Este código de ejemplo muestra las opciones de configuración para ejecutar el experimento con la documentación 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]
)

Paso 4: Realice el experimento

Ejecute el optimizador para crear los patrones RAG utilizando las opciones de configuración especificadas. Utilice el resultado de la extracción de texto como entrada en su experimento RAG de AutoAI.

En este ejemplo de código para ejecutar un experimento Chroma, la tarea se ejecuta en modo interactivo. Puede ejecutar la tarea en segundo plano cambiando background_mode a 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
)

Paso 5: Revisar los patrones y seleccionar el mejor

Una vez finalizado con éxito el experimento AutoAI RAG, puede revisar los patrones. Utilice el método summary para listar los patrones completados y la información de las métricas de evaluación en forma de Pandas DataFrame para que pueda revisar los patrones, clasificados según su rendimiento respecto a la métrica optimizada.

summary = rag_optimizer.summary()
summary

Por ejemplo, los resultados del patrón se muestran así:

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.

Revisión de los resultados de los experimentos en Cloud Object Storage

Si el estado final del experimento es fallido o error, utilice rag_optimizer.get_logs() o consulte los resultados del experimento para comprender qué ha fallado. Los resultados de los experimentos y los registros se almacenan en la instancia predeterminada de Cloud Object Storage vinculada a su cuenta. Por defecto, los resultados se guardan en el directorio default_autoai_rag_out.

Los resultados se organizan por patrones. Por ejemplo:

|-- Pattern1
|      | -- evaluation_results.json
|      | -- indexing_inference_notebook.ipynb (Chroma)
|-- Pattern2
|    ...
|-- training_status.json

Cada patrón contiene estos resultados:

• El archivo evaluation_results.json contiene los resultados de la evaluación de cada pregunta de referencia.
• La página indexing_inference_notebook.ipynb contiene el código Python para construir un índice de base de datos vectorial, así como para construir la función de recuperación y generación. El cuaderno presenta comandos para recuperar datos, crear fragmentos e incrustaciones, así como para recuperar fragmentos, crear preguntas y generar respuestas.

rag_optimizer.get_inference_notebook(pattern_name='Pattern3')