Codifica di un esperimento RAG AutoAI con un modello di fondazione personalizzato

Passo 1: Preparare i prerequisiti per la distribuzione del modello di fondazione personalizzato

1. Scaricate l'istantanea del modello.

   from pathlib import Path
   from huggingface_hub import snapshot_download
   
   byom_cache_dir = Path("your", "model", "cache", "dir")
   
   if not byom_cache_dir.exists():
       raise FileExistsError("Please use the path which exists.")
   
   if byom_cache_dir.is_file():
       raise NotADirectoryError("Please use the path which points to a directory.")
   
   snapshot_download(HUGGING_FACE_MODEL_REPOSITORY, cache_dir=byom_cache_dir)
   

2. Utilizzare il codice per inizializzare il client. Ad esempio:

   from ibm_watsonx_ai import APIClient, Credentials
   
   credentials = Credentials(
                   url=URL,
                   username=USERNAME,
                   password=PASSWORD,
                   instance_id=INSTANCE_ID,
                   version=VERSION,
                   verify=False,
               )
   
   client = APIClient(credentials=credentials,  project_id=PROJECT_ID)
   

3. Collegarsi al sito S3Bucket.

   from ibm_watsonx_ai.helpers.connections import DataConnection, S3Location
   
   location = S3Location(bucket=BUCKET_NAME, path=BUCKET_MODEL_DIR_NAME)
   data_connection = DataConnection(location=location, connection_asset_id=DATASOURCE_CONNECTION_ASSET_ID)
   data_connection.set_client(api_client=client)
   

4. Caricare i file del modello sul sito S3Bucket.

   model_files = byom_cache_dir / "model_dir_name" / "snapshots" / "snapshot_id"
   
   if not model_files.exists():
       raise FileExistsError("Please use the snapshot path which exists.")
   
   if model_files.is_file():
       raise NotADirectoryError("Please use the snapshot path which points to a directory.")
   
   for model_file in model_files.iterdir():
   
       # avoid uploading unnecessary files
       if model_file.name.startswith("."):
           continue
   
       data_connection.write(data=str(model_file), remote_name=model_file.name)
   

Fase 2: Distribuzione del modello

Per distribuire il modello di base personalizzato, seguire i passaggi descritti nella documentazione sui modelli personalizzati.

Fase 3: preparazione dei dati 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 Ottenere e preparare i dati in un progetto.

• Formati supportati: PDF, HTML, DOCX, Markdown, testo semplice
• Collegatevi ai dati di un bucket Cloud Object Storage, a una cartella di un bucket o specificate fino a 20 file.
• AutoAI utilizza un campione di documenti per l'esecuzione dell'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

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

Fase 4: preparazione dei dati di valutazione

1. Scaricate il documento granite_code_models.pdf .

   import wget
   
   data_url = "https://arxiv.org/pdf/2405.04324"
   byom_input_filename = "granite_code_models.pdf"
   wget.download(data_url, byom_input_filename)
   

2. Preparare i dati di valutazione.

   Per correct_answer_document_ids, indicare il nome del file scaricato.

   import json
   
   local_benchmark_json_filename = "benchmark.json"
   
   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": [byom_input_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": [byom_input_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": [byom_input_filename]
       },
   ]
   
   with open(local_benchmark_json_filename, mode="w", encoding="utf-8") as fp:
       json.dump(benchmarking_data, fp, indent=4)
   

3. Caricare i file di valutazione nel proprio bucket Cloud Object Storage.

   documents_dir_location = S3Location(bucket=BUCKET_NAME, path=byom_input_filename)
   documents_dir_data_connection = DataConnection(location=documents_dir_location, connection_asset_id=DATASOURCE_CONNECTION_ASSET_ID)
   documents_dir_data_connection.set_client(api_client=client)
   documents_dir_data_connection.write(data=byom_input_filename, remote_name=byom_input_filename)
   
   benchmark_file_location = S3Location(bucket=BUCKET_NAME, path=BUCKET_BENCHMARK_JSON_FILE_PATH)
   benchmark_file_data_connection = DataConnection(location=benchmark_file_location, connection_asset_id=DATASOURCE_CONNECTION_ASSET_ID)
   benchmark_file_data_connection.set_client(api_client=client)
   benchmark_file_data_connection.write(data=local_benchmark_json_filename)
   

Fase 5: Esecuzione dell'esperimento AutoAI RAG con il modello di fondazione personalizzato

Eseguire l'esperimento con Python SDK. Per deployment_id, fornire l'ID del modello di fondazione personalizzato distribuito.

from ibm_watsonx_ai.experiment import AutoAI
from ibm_watsonx_ai.foundation_models.schema import (
        AutoAIRAGCustomModelConfig,
        AutoAIRAGModelParams
)

experiment = AutoAI(credentials, project_id=PROJECT_ID)

custom_prompt_template_text = "Answer my question {question} related to these documents {reference_documents}."
custom_context_template_text = "My document {document}"

parameters = AutoAIRAGModelParams(max_sequence_length=32_000)

custom_foundation_model = AutoAIRAGCustomModelConfig(
    deployment_id=deployment_id,
    project_id=PROJECT_ID,
    prompt_template_text=custom_prompt_template_text,
    context_template_text=custom_context_template_text,
    parameters=parameters
)

rag_optimizer = experiment.rag_optimizer(
    name='AutoAI RAG - Custom foundation model experiment',
    description = "AutoAI RAG experiment with custom foundation model.",
    max_number_of_rag_patterns=4,
    optimization_metrics=['faithfulness'],
    foundation_models=[custom_foundation_model],
)

rag_optimizer.run(
    test_data_references=[benchmark_file_data_connection],
    input_data_references=[documents_dir_data_connection],
)

Per ottenere i dettagli del lavoro utilizzare:

rag_optimizer.get_details()

Una volta completato lo stato, si può passare alla fase successiva.

Fase 6: 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 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:

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.

rag_optimizer.get_inference_notebook(pattern_name='Pattern3')