Filtrado de metadatos para datos tabulares con Knowledge Bases para Amazon Bedrock

La roca madre del Amazonas es un servicio totalmente administrado que ofrece una selección de modelos de base (FM) de alto rendimiento de empresas líderes en inteligencia artificial (IA) como AI21 Labs, Anthropic, Cohere, Meta, Mistral AI, Stability AI y Amazon a través de una única API. Para equipar a los FM con información actualizada y exclusiva, las organizaciones utilizan Retrieval Augmented Generation (RAG), una técnica que obtiene datos de fuentes de datos de la empresa y enriquece el mensaje para brindar respuestas más relevantes y precisas. Bases de conocimiento para Amazon Bedrock es una capacidad completamente administrada que lo ayuda a implementar todo el flujo de trabajo de RAG, desde la ingesta hasta la recuperación y el aumento de solicitudes. Sin embargo, la información sobre un conjunto de datos puede estar en otro conjunto de datos, llamado metadatos. Sin el uso de metadatos, su proceso de recuperación puede provocar la recuperación de resultados no relacionados, lo que disminuye la precisión de FM y aumenta el costo en el token de solicitud de FM.

El 27 de marzo de 2024, Amazon Bedrock anunció una nueva característica clave llamada filtrado de metadatos y también cambió el motor predeterminado. Este cambio le permite usar campos de metadatos durante el proceso de recuperación. Sin embargo, los campos de metadatos deben configurarse durante el proceso de ingesta de la base de conocimientos. A menudo, puede tener datos tabulares donde los detalles sobre un campo están disponibles en otro campo. Además, puede tener el requisito de citar el documento de texto exacto o el campo de texto para evitar alucinaciones. En esta publicación, le mostramos cómo usar la nueva función. filtrado de metadatos función con bases de conocimiento para Amazon Bedrock para dichos datos tabulares.

Descripción general de la solución

La solución consta de los siguientes pasos de alto nivel:

1. Preparar datos para el filtrado de metadatos.
2. Crear e incorporar datos y metadatos en la base de conocimientos.
3. Recupere datos de la base de conocimientos mediante el filtrado de metadatos.

Preparar datos para el filtrado de metadatos

Al momento de escribir este artículo, las bases de conocimiento para Amazon Bedrock son compatibles Amazon OpenSearch sin servidor, Aurora amazónica, Piña, Redis Enterprisey Atlas de MongoDB como proveedores de almacenamiento de vectores subyacentes. En esta publicación, creamos y accedemos a un almacén de vectores de OpenSearch Serverless utilizando el SDK de Amazon Bedrock Boto3. Para obtener más detalles, consulte Configurar un índice vectorial para su base de conocimiento en un almacén de vectores compatible.

Para esta publicación, creamos una base de conocimiento utilizando el conjunto de datos públicos Food.com – Recetas y reseñasLa siguiente captura de pantalla muestra un ejemplo del conjunto de datos.

El TotalTime Está en formato ISO 8601. Puedes convertirlo a minutos usando la siguiente lógica:

# Function to convert ISO 8601 duration to minutes
def convert_to_minutes(duration):
    hours = 0
    minutes = 0
    
    # Find hours and minutes using regex
    match = re.match(r'PT(?:(\d+)H)?(?:(\d+)M)?', duration)
    
    if match:
        if match.group(1):
            hours = int(match.group(1))
        if match.group(2):
            minutes = int(match.group(2))
    
    # Convert total time to minutes
    total_minutes = hours * 60 + minutes
    return total_minutes

df['TotalTimeInMinutes'] = df['TotalTime'].apply(convert_to_minutes)

Después de convertir algunas de las características como CholesterolContent, SugarContent, y RecipeInstructionsel marco de datos se parece a la siguiente captura de pantalla.

Para permitir que el FM apunte a un menú específico con un enlace (citar el documento), dividimos cada fila de los datos tabulares en un solo archivo de texto, y cada archivo contiene RecipeInstructions como el campo de datos y TotalTimeInMinutes, CholesterolContent, y SugarContent como metadatos. Los metadatos deben guardarse en un archivo JSON separado con el mismo nombre que el archivo de datos y .metadata.json se añade a su nombre. Por ejemplo, si el nombre del archivo de datos es 100.txtel nombre del archivo de metadatos debe ser 100.txt.metadata.jsonPara más detalles, véase Agregue metadatos a sus archivos para permitir el filtradoAdemás, el contenido del archivo de metadatos debe tener el siguiente formato:

{
"metadataAttributes": {
"${attribute1}": "${value1}",
"${attribute2}": "${value2}",
...
}
}

Para simplificar, solo procesamos las 2000 filas superiores para crear la base de conocimiento.

1. Después de importar las bibliotecas necesarias, cree un directorio local utilizando el siguiente código Python:

   import pandas as pd
   import os, json, tqdm, boto3
   
   metafolder="multi_file_recipe_data"os.mkdir(metafolder)

2. Iterar sobre las 2000 filas superiores para crear archivos de datos y metadatos para almacenar en la carpeta local:

   for i in tqdm.trange(2000):
       desc = str(df['RecipeInstructions'][i])
       meta = {
       "metadataAttributes": {
           "Name": str(df['Name'][i]),
           "TotalTimeInMinutes": str(df['TotalTimeInMinutes'][i]),
           "CholesterolContent": str(df['CholesterolContent'][i]),
           "SugarContent": str(df['SugarContent'][i]),
       }
       }
       filename = metafolder+'/' + str(i+1)+ '.txt'
       f = open(filename, 'w')
       f.write(desc)
       f.close()
       metafilename = filename+'.metadata.json'
       with open( metafilename, 'w') as f:
           json.dump(meta, f)
   

3. Crear un Servicio de almacenamiento simple de Amazon (Amazon S3) depósito denominado food-kb y subir los archivos:

   # Upload data to s3
   s3_client = boto3.client("s3")
   bucket_name = "recipe-kb"
   data_root = metafolder+'/'
   def uploadDirectory(path,bucket_name):
       for root,dirs,files in os.walk(path):
           for file in tqdm.tqdm(files):
               s3_client.upload_file(os.path.join(root,file),bucket_name,file)
   
   uploadDirectory(data_root, bucket_name)

Crear e incorporar datos y metadatos en la base de conocimientos

Cuando la carpeta S3 esté lista, puedes crear la base de conocimiento en la consola de Amazon Bedrock usando el SDK de acuerdo con este cuaderno de ejemplo.

Recuperar datos de la base de conocimientos mediante el filtrado de metadatos

Ahora, recuperemos algunos datos de la base de conocimientos. Para esta publicación, usamos Anthropic Claude Sonnet en Amazon Bedrock para nuestro FM, pero puede elegir entre una variedad de Modelos Bedrock de AmazonPrimero, debe configurar las siguientes variables, donde kb_id es el ID de su base de conocimiento. El ID de la base de conocimiento se puede encontrar mediante programación, como se muestra en la ejemplo de cuadernoo desde la consola de Amazon Bedrock navegando a la base de conocimiento individual, como se muestra en la siguiente captura de pantalla.

Establezca los parámetros necesarios de Amazon Bedrock utilizando el siguiente código:

import boto3
import pprint
from botocore.client import Config
import json

pp = pprint.PrettyPrinter(indent=2)
session = boto3.session.Session()
region = session.region_name
bedrock_config = Config(connect_timeout=120, read_timeout=120, retries={'max_attempts': 0})
bedrock_client = boto3.client('bedrock-runtime', region_name = region)
bedrock_agent_client = boto3.client("bedrock-agent-runtime",
                              config=bedrock_config, region_name = region)
kb_id = "EIBBXVFDQP"
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'

# retrieve api for fetching only the relevant context.

query = " Tell me a recipe that I can make under 30 minutes and has cholesterol less than 10 "

relevant_documents = bedrock_agent_runtime_client.retrieve(
    retrievalQuery= {
        'text': query
    },
    knowledgeBaseId=kb_id,
    retrievalConfiguration= {
        'vectorSearchConfiguration': {
            'numberOfResults': 2 
        }
    }
)
pp.pprint(relevant_documents["retrievalResults"])

El código siguiente es el resultado de la recuperación de la base de conocimiento sin filtrado de metadatos para la consulta “Dime una receta que pueda hacer en menos de 30 minutos y que tenga un colesterol inferior a 10”. Como podemos ver, de las dos recetas, las duraciones de preparación son 30 y 480 minutos, respectivamente, y los contenidos de colesterol son 86 y 112,4, respectivamente. Por lo tanto, la recuperación no sigue la consulta con precisión.

El siguiente código demuestra cómo utilizar la API de recuperación con los filtros de metadatos configurados con un contenido de colesterol menor a 10 y minutos de preparación menores a 30 para la misma consulta:

def retrieve(query, kbId, numberOfResults=5):
    return bedrock_agent_client.retrieve(
        retrievalQuery= {
            'text': query
        },
        knowledgeBaseId=kbId,
        retrievalConfiguration= {
            'vectorSearchConfiguration': {
                'numberOfResults': numberOfResults,
                 "filter": {
                            'andAll':[
                                {
                                "lessThan": {
                                "key": "CholesterolContent",
                                "value": 10
                                }
                            },
                                {
                            "lessThan": {
                                "key": "TotalTimeInMinutes",
                                "value": 30
                            }
                                }
                            ]
                        }
            }
        }
    ) 
query = "Tell me a recipe that I can make under 30 minutes and has cholesterol less than 10" 
response = retrieve(query, kb_id, 2)
retrievalResults = response['retrievalResults']
pp.pprint(retrievalResults)

Como podemos observar en los siguientes resultados, de las dos recetas, los tiempos de preparación son 27 y 20, respectivamente, y los contenidos de colesterol son 0 y 0, respectivamente. Con el uso del filtrado de metadatos, obtenemos resultados más precisos.

El siguiente código muestra cómo obtener una salida precisa utilizando el mismo filtrado de metadatos con el retrieve_and_generate API. Primero, configuramos el mensaje y luego configuramos la API con el filtrado de metadatos:

prompt = f"""
Human: You have great knowledge about food, so provide answers to questions by using fact. 
If you don't know the answer, just say that you don't know, don't try to make up an answer.

Assistant:"""

def retrieve_and_generate(query, kb_id,modelId, numberOfResults=10):
    return bedrock_agent_client.retrieve_and_generate(
        input= {
            'text': query,
        },
        retrieveAndGenerateConfiguration={
        'knowledgeBaseConfiguration': {
            'generationConfiguration': {
                'promptTemplate': {
                    'textPromptTemplate': f"{prompt} $search_results$"
                }
            },
            'knowledgeBaseId': kb_id,
            'modelArn': model_id,
            'retrievalConfiguration': {
                'vectorSearchConfiguration': {
                    'numberOfResults': numberOfResults,
                    'overrideSearchType': 'HYBRID',
                     "filter": {
                            'andAll':[
                                {
                                "lessThan": {
                                "key": "CholesterolContent",
                                "value": 10
                                }
                            },
                                {
                            "lessThan": {
                                "key": "TotalTimeInMinutes",
                                "value": 30
                            }
                                }
                            ]
                        },
                }
        }
                    },
        'type': 'KNOWLEDGE_BASE'
    }
    )
    
query = "Tell me a recipe that I can make under 30 minutes and has cholesterol less than 10"
response = retrieve_and_generate(query, kb_id,modelId, numberOfResults=10)
pp.pprint(response['output']['text'])

Como podemos ver en la siguiente salida, el modelo devuelve una receta detallada que sigue el filtrado de metadatos indicado de menos de 30 minutos de tiempo de preparación y un contenido de colesterol inferior a 10.

Limpiar

Asegúrese de comentar la siguiente sección si planea utilizar la base de conocimiento que creó para crear su aplicación RAG. Si solo desea probar la creación de la base de conocimiento mediante el SDK, asegúrese de eliminar todos los recursos que se crearon porque incurrirá en costos por almacenar documentos en el índice de OpenSearch Serverless. Vea el siguiente código:

bedrock_agent_client.delete_data_source(dataSourceId = ds["dataSourceId"], knowledgeBaseId=kb['knowledgeBaseId'])
bedrock_agent_client.delete_knowledge_base(knowledgeBaseId=kb['knowledgeBaseId'])
oss_client.indices.delete(index=index_name)
aoss_client.delete_collection(id=collection_id)
aoss_client.delete_access_policy(type="data", name=access_policy['accessPolicyDetail']['name'])
aoss_client.delete_security_policy(type="network", name=network_policy['securityPolicyDetail']['name'])
aoss_client.delete_security_policy(type="encryption", name=encryption_policy['securityPolicyDetail']['name'])
# Delete roles and polices 
iam_client.delete_role(RoleName=bedrock_kb_execution_role)
iam_client.delete_policy(PolicyArn=policy_arn)

Conclusión

En esta publicación, explicamos cómo dividir un gran conjunto de datos tabulares en filas para configurar una base de conocimiento con metadatos para cada uno de esos registros y cómo recuperar los resultados con el filtrado de metadatos. También mostramos cómo recuperar resultados con metadatos es más preciso que recuperar resultados sin el filtrado de metadatos. Por último, mostramos cómo usar el resultado con un FM para obtener resultados precisos.

Para explorar más a fondo las capacidades de las bases de conocimiento para Amazon Bedrock, consulte los siguientes recursos:

Sobre el Autor

Tanay Chowdhury es un científico de datos en el Centro de Innovación de IA Generativa de Amazon Web Services. Ayuda a los clientes a resolver sus problemas comerciales mediante IA Generativa y Aprendizaje Automático.