Codificação de um experimento AutoAI RAG com extração de texto

Documentos de base

Prepare e conecte-se aos documentos de aterramento que você usará para executar o experimento AutoAI RAG com o serviço de extração de texto.

1. Crie uma conexão com Cloud Object Storage e obtenha o ID.

   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)
   

2. Prepare dois ativos de conexão, um para a entrada e outro para a saída do serviço de extração de texto.

   text_extraction_input_filename = <TEXT EXTRACTION INPUT FILENAME>
   text_extraction_result_filename = <TEXT EXTRACTION RESULT FILENAME>
   

   from ibm_watsonx_ai.helpers import DataConnection, S3Location
   
   input_data_reference = DataConnection(
       connection_asset_id=cos_connection_id,
       location=S3Location(
           bucket=<BUCKET_NAME>,
           path=text_extraction_input_filename
       ),
   )
   input_data_reference.set_client(client)
   
   result_data_reference = DataConnection(
       connection_asset_id=cos_connection_id,
       location=S3Location(
           bucket=<BUCKET_NAME>,
           path=text_extraction_result_filename
       )
   )
   result_data_reference.set_client(client)
   

Dados de avaliação

Para entrada de dados de avaliação:

• Os dados devem estar no formato JSON com um esquema fixo com estes campos: question, correct_answer, correct_answer_document_ids
• correct_answer_document_ids deve se referir ao arquivo de saída do serviço de extração de texto

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_result_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_result_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_result_filename],
    },
]

import os, json

test_filename = "benchmark.json"

if not os.path.isfile(test_filename):
    with open(test_filename, "w") as json_file:
        json.dump(benchmarking_data, json_file, indent=4)

test_data_reference = DataConnection(
    connection_asset_id=cos_connection_id,
    location=S3Location(bucket=<BUCKET_NAME>, path=test_filename),
)
test_data_reference.set_client(client)

# Upload file to the COS bucket
test_data_reference.write(test_filename)

test_data_references = [test_data_reference]

Selecione um padrão para testar localmente

A próxima etapa é selecionar um padrão e testá-lo localmente.

best_pattern = rag_optimizer.get_pattern()

Consultar o padrão RAG localmente.

from ibm_watsonx_ai.deployments import RuntimeContext

runtime_context = RuntimeContext(api_client=client)
inference_service_function = 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_function(context)["body"]["choices"][0]["message"]["content"])

A resposta do modelo é semelhante a esta:

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.

Obter um notebook de inferência e indexação

Para fazer download de um notebook de inferência específico, use o endereço get_inference_notebook(). Se você deixar o endereço pattern_name vazio, o método fará o download do notebook do melhor padrão calculado.

rag_optimizer.get_inference_notebook(pattern_name='Pattern3')

Para obter mais informações e exemplos de código, consulte o notebook de serviço AutoAI RAG with watsonx Text Extraction.