Codificación de un experimento RAG AutoAI con un almacén de vectores

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.3.17'
pip install langchain-community==0.2.4

• Si está utilizando watsonx.data para crear una tienda de vectores Milvus, compruebe que tiene una instancia de watsonx.data.

• Introduzca las credenciales de la tarea. Véase Añadir credenciales de tarea.

• watsonx.ai Servicio en tiempo de ejecución. Véase Creación de servicios.

• Introduzca la clave API. Véase Gestión de la clave API de usuario.

• Utilice este código 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 Buscar 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

from ibm_watsonx_ai.helpers import DataConnection, S3Location

datasource_name = 'bluemixcloudobjectstorage'

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=<BUCKET_NAME>,
            path=<BUCKET_PATH>
        )
    )
]

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

[
    {
        "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"
        ]
    }
]

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

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

Paso 2: 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. Para conocer las opciones de configuración disponibles, consulte Parámetros de configuración para los ajustes del experimento.

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

from ibm_watsonx_ai.foundation_models.schema import (
    AutoAIRAGModelConfig,
    AutoAIRAGModelParams,
)

parameters = AutoAIRAGModelParams(max_sequence_length=32_000)

foundation_model = AutoAIRAGModelConfig(
    model_id="ibm/granite-13b-instruct-v2",
    parameters=parameters,
    prompt_template_text="Answer my question {question} related to these documents {reference_documents}.",
    context_template_text="My document {document}",
    word_to_token_ratio=1.5,
)

chunking_config = {
    "method": "recursive",
    "chunk_size": 256,
    "chunk_overlap": 128,
}

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=[
        "mistralai/mixtral-8x7b-instruct-v01",
        foundation_model,
    ],
    chunking=[chunking_config],
    max_number_of_rag_patterns=5,
    optimization_metrics=[AutoAI.RAGMetrics.ANSWER_CORRECTNESS]
)

Paso 3: Ejecutar el experimento

Ejecute el optimizador para crear los patrones RAG utilizando las opciones de configuración especificadas. En este ejemplo de código, la tarea se ejecuta en modo interactivo. Puedes ejecutar la tarea en segundo plano cambiando el background_mode a 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
)

Paso 4: Revisar los patrones y seleccionar el mejor

Una vez finalizado con éxito el experimento RAG AutoAI, 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 un Pandas DataFrame para que pueda revisar los patrones, clasificados según su rendimiento frente a la métrica optimizada.

summary = rag_optimizer.summary()
summary

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

best_pattern = rag_optimizer.get_pattern()

from ibm_watsonx_ai.deployments import RuntimeContext

runtime_context = RuntimeContext(api_client=client)
inference_service = best_pattern.inference_service(runtime_context)[0]

question = "How to use new approach of providing credentials to APIClient?"

context = RuntimeContext(
    api_client=client,
    request_payload_json={"messages": [{"role": "user", "content": question}]},
)
print(inference_service(context)["body"]["choices"][0]["message"]["content"])

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.

Paso 5: Despliegue de un patrón

Después de probar un patrón localmente, puede desplegar el patrón para obtener el punto final e incluirlo en las aplicaciones. El despliegue se realiza almacenando la función GAR definida y, a continuación, creando un activo desplegado. Para obtener más información sobre los despliegues, consulte Despliegue y gestión de activos de IA y Despliegues en línea.

Para crear el despliegue:

deployment_details = best_pattern.inference_service.deploy(
    name="AutoAI RAG deployment - ibm_watsonx_ai documentation",
    space_id=space_id,
    deploy_params={"tags": ["wx-autoai-rag"]}
)

Recupera el ID de despliegue del activo desplegado.

deployment_id = client.deployments.get_id(deployment_details)

El servicio RAG ya está desplegado en un espacio y disponible para pruebas.

payload = {
    "messages": [{"role": "user", "content": "How to use new approach of providing credentials to APIClient?"}]
}

score_response = client.deployments.run_ai_service(deployment_id, payload)
answer = score_response["choices"][0]["message"]["content"]
print(answer)

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 resultados de 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 ido mal. Los resultados de los experimentos y los registros se almacenan en la instancia predeterminada Cloud Object Storage vinculada a su cuenta. De forma predeterminada, los resultados se guardan por ID de formación del experimento en el directorio default_autoai_rag_out .

Los resultados se organizan por patrones. Por ejemplo:

|-- Pattern1
|      | -- evaluation_results.json
|      | -- indexing_notebook.ipynb (Milvus)
|      | -- inference_notebook.ipynb (Milvus)
|-- Pattern2
|    ...
|-- training_status.json

Cada patrón contiene estos resultados:

• El archivo evaluation_results.json contiene los resultados de la evaluación para cada pregunta de referencia.
• El indexing_notebook.ipynb contiene el código python para construir un índice de base de datos vectorial. Introduce comandos para la recuperación de datos, el chunking y la creación de embeddings.
• El cuaderno inference_notebook.ipynb se centra en recuperar pasajes relevantes de una base de conocimientos para las consultas de los usuarios y generar respuestas alimentando los pasajes recuperados en un gran modelo lingüístico.

Puedes revisar los cuadernos o ejecutarlos añadiendo credenciales de autenticación.

rag_optimizer.get_inference_notebook(pattern_name='Pattern3')

Paso 6: Limpieza (opcional)

Si desea eliminar su colección de la base de datos de vectores Milvus, utilice el SDK de python para Milvus.

Para encontrar el nombre de la colección, vaya a Detalles del patrón y vea Nombre del índice del almacén vectorial.

Por ejemplo:

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)

Próximos pasos

• Ejecute el cuaderno de inferencias con nuevas preguntas para utilizar el patrón GAR seleccionado.
• Utilice los documentos indexados de este experimento en la página Prompt Lab para fundamentar las indicaciones de un modelo de fundación. Consulte Uso de un índice AutoAI Rag para chatear con documentos.

Tema principal: Automatización de un patrón RAG con el SDK AutoAI