Mejore la precisión de respuesta del asistente de IA mediante bases de conocimiento para Amazon Bedrock y un modelo de reclasificación

Los chatbots y asistentes virtuales de IA se han vuelto cada vez más populares en los últimos años gracias a los avances de los modelos de lenguaje de gran tamaño (LLM, por sus siglas en inglés). Estos modelos, entrenados con un gran volumen de conjuntos de datos, incorporan componentes de memoria en su diseño arquitectónico, lo que les permite entender y comprender el contexto textual.

Los casos de uso más comunes de los asistentes de chatbot se centran en algunas áreas clave, como la mejora de las experiencias de los clientes, el aumento de la productividad y la creatividad de los empleados o la optimización de los procesos empresariales. Por ejemplo, la atención al cliente, la resolución de problemas y la búsqueda interna y externa basada en conocimientos.

A pesar de estas capacidades, un desafío clave con los chatbots es generar respuestas precisas y de alta calidad. Una forma de resolver este desafío es usar la Generación Aumentada de Recuperación (RAG). RAG es el proceso de optimizar el resultado de un LLM para que haga referencia a una base de conocimiento autorizada fuera de sus fuentes de datos de entrenamiento antes de generar una respuesta. El reranking busca mejorar la relevancia de la búsqueda al reordenar el conjunto de resultados devuelto por un recuperador con un modelo diferente. En esta publicación, explicamos cómo dos técnicas (RAG y reranking) pueden ayudar a mejorar las respuestas de los chatbots mediante Bases de conocimiento para Amazon Bedrock.

Descripción general de la solución

RAG es una técnica que combina las ventajas de la recuperación de la base de conocimientos y los modelos generativos para la generación de texto. Funciona recuperando primero las respuestas relevantes de una base de datos y luego utilizando esas respuestas como contexto para alimentar el modelo generativo y producir un resultado final. El uso de un enfoque RAG para crear un chatbot tiene muchas ventajas. Por ejemplo, recuperar respuestas de su base de datos antes de generar una respuesta podría proporcionar respuestas más relevantes y coherentes. Esto ayuda a mejorar el flujo de la conversación. RAG también se escala mejor con más datos en comparación con los modelos generativos puros y no requiere un ajuste fino del modelo cuando se agregan nuevos datos a la base de conocimientos. Además, el componente de recuperación permite que el modelo incorpore conocimiento externo recuperando información de fondo relevante de su base de datos. Este enfoque ayuda a proporcionar respuestas objetivas, detalladas y con conocimiento.

Para encontrar una respuesta, RAG adopta un enfoque que utiliza la búsqueda vectorial en todos los documentos. La ventaja de utilizar la búsqueda vectorial es la velocidad y la escalabilidad. En lugar de escanear cada documento para encontrar la respuesta, con el enfoque RAG, se convierten los textos (base de conocimiento) en incrustaciones y se almacenan estas incrustaciones en la base de datos. Las incrustaciones son una versión comprimida de los documentos, representada por una matriz de valores numéricos. Una vez almacenadas las incrustaciones, la búsqueda vectorial consulta la base de datos vectorial para encontrar la similitud en función de los vectores asociados con los documentos. Por lo general, una búsqueda vectorial devolverá los k documentos más relevantes según la pregunta del usuario y devolverá los k resultados. Sin embargo, debido a que el algoritmo de similitud en una base de datos vectorial funciona en vectores y no en documentos, la búsqueda vectorial no siempre devuelve la información más relevante en los k resultados principales. Esto afecta directamente la precisión de la respuesta si los contextos más relevantes no están disponibles para el LLM.

La reclasificación es una técnica que puede mejorar aún más las respuestas al seleccionar la mejor opción entre varias posibles respuestas. La siguiente arquitectura ilustra cómo podría funcionar una solución de reclasificación.

Vamos a crear una solución de preguntas y respuestas, donde ingerimos El gran Gatsby, una novela de 1925 del escritor estadounidense F. Scott Fitzgerald. Este libro está disponible públicamente a través de Proyecto GutenbergUsamos bases de conocimiento para Amazon Bedrock para implementar el flujo de trabajo RAG de extremo a extremo e incorporar las incrustaciones en un Amazon OpenSearch sin servidor Recopilación de búsquedas vectoriales. Luego recuperamos las respuestas utilizando RAG estándar y un RAG de dos etapas, que implica una API de reclasificación. Luego comparamos los resultados de estos dos métodos.

El ejemplo de código está disponible en este Repositorio de GitHub.

En las siguientes secciones, repasaremos los pasos de alto nivel:

1. Preparar el conjunto de datos.
2. Genere preguntas a partir del documento utilizando un LLM de Amazon Bedrock.
3. Crear una base de conocimientos que contenga este libro.
4. Recuperar respuestas utilizando la base de conocimientos retrieve API
5. Evalúe la respuesta utilizando la RAGAS
6. Recupere respuestas nuevamente ejecutando un RAG de dos etapas, utilizando la base de conocimiento retrieve API y luego aplicar reranking en el contexto.
7. Evaluar la respuesta RAG de dos etapas utilizando el marco RAGAS.
8. Compare los resultados y el rendimiento de cada enfoque RAG.

Para fines de eficiencia, proporcionamos un código de muestra en un computadora portátil Se utiliza para generar un conjunto de preguntas y respuestas. Estos pares de preguntas y respuestas se utilizan en el proceso de evaluación de RAG. Recomendamos encarecidamente que una persona valide cada pregunta y respuesta para comprobar su precisión.

Las siguientes secciones explican los pasos principales con la ayuda de bloques de código.

Prerrequisitos

Para clonar el repositorio de GitHub en su máquina local, abra una ventana de terminal y ejecute los siguientes comandos:

git clone https://github.com/aws-samples/amazon-bedrock-samples
cd knowledge-bases/features-examples/03-advanced-concepts/reranking

Preparar el conjunto de datos

Descargue el libro desde Sitio web del Proyecto GutenbergPara esta publicación, creamos 10 documentos grandes a partir de este libro y los subimos a Servicio de almacenamiento simple de Amazon (Amazonas S3):

target_url = "https://www.gutenberg.org/ebooks/64317.txt.utf-8" # the great gatsby
data = urllib.request.urlopen(target_url)
my_texts = []
for line in data:
my_texts.append(line.decode())

doc_size = 700 # size of the document to determine number of batches
batches = math.ceil(len(my_texts) / doc_size)

sagemaker_session = sagemaker.Session()
default_bucket = sagemaker_session.default_bucket()
s3_prefix = "bedrock/knowledgebase/datasource"

start = 0
s3 = boto3.client("s3")
for batch in range(batches):
    batch_text_arr = my_texts[start:start+doc_size]
    batch_text = "".join(batch_text_arr)
    s3.put_object(
        Body=batch_text,
        Bucket=default_bucket,
        Key=f"{s3_prefix}/{start}.txt"
    )
    start += doc_size  

Crear una base de conocimientos para Bedrock

Si no está familiarizado con el uso de bases de conocimiento para Amazon Bedrock, consulte Las bases de conocimiento para Amazon Bedrock ahora son compatibles con los modelos de integración de Amazon Aurora PostgreSQL y Coheredonde describimos cómo Knowledge Bases para Amazon Bedrock administra el flujo de trabajo de RAG de extremo a extremo.

En este paso, se crea una base de conocimiento mediante un cliente Boto3. Se utiliza Amazon Titan Text Embedding v2 para convertir los documentos en incrustaciones (’embeddingModelArn’) y se apunta al depósito S3 que se creó anteriormente como fuente de datos (dataSourceConfiguration):

bedrock_agent = boto3.client("bedrock-agent")
response = bedrock_agent.create_knowledge_base(
    name=knowledge_base_name,
    description='Knowledge Base for Bedrock',
    roleArn=role_arn,
    knowledgeBaseConfiguration={
        'type': 'VECTOR',
        'vectorKnowledgeBaseConfiguration': {
            'embeddingModelArn': embedding_model_arn
        }
    },
    storageConfiguration={
        'type': 'OPENSEARCH_SERVERLESS',
        'opensearchServerlessConfiguration': {
            'collectionArn': collection_arn,
            'vectorIndexName': index_name,
            'fieldMapping': {
                'vectorField':  "bedrock-knowledge-base-default-vector",
                'textField': 'AMAZON_BEDROCK_TEXT_CHUNK',
                'metadataField': 'AMAZON_BEDROCK_METADATA'
            }
        }
    }
)
knowledge_base_id = response['knowledgeBase']['knowledgeBaseId']
knowledge_base_name = response['knowledgeBase']['name']

response = bedrock_agent.create_data_source(
    knowledgeBaseId=knowledge_base_id,
    name=f"{knowledge_base_name}-ds",
    dataSourceConfiguration={
        'type': 'S3',
        's3Configuration': {
            'bucketArn': f"arn:aws:s3:::{bucket}",
            'inclusionPrefixes': [
                f"{s3_prefix}/",
            ]
        }
    },
    vectorIngestionConfiguration={
        'chunkingConfiguration': {
            'chunkingStrategy': 'FIXED_SIZE',
            'fixedSizeChunkingConfiguration': {
                'maxTokens': 300,
                'overlapPercentage': 10
            }
        }
    }
)
data_source_id = response['dataSource']['dataSourceId']

response = bedrock_agent.start_ingestion_job(
    knowledgeBaseId=knowledge_base_id,
    dataSourceId=data_source_id,
)

Generar preguntas a partir del documento

Usamos Anthropic Claude en Amazon Bedrock para generar una lista de 10 preguntas y las respuestas correspondientes. Los datos de preguntas y respuestas sirven como base para la evaluación de RAG en función de los enfoques que vamos a implementar. Definimos las respuestas generadas a partir de este paso como datos de verdad de campo. Vea el siguiente código:

prompt_template = """The question should be diverse in nature \
across the document. The question should not contain options, not start with Q1/ Q2. \
Restrict the question to the context information provided.\

<document>
{{document}}
</document>

Think step by step and pay attention to the number of question to create.

Your response should follow the format as followed:

Question: question
Answer: answer

"""
system_prompt = """You are a professor. Your task is to setup 1 question for an upcoming \
quiz/examination based on the given document wrapped in <document></document> XML tag."""

prompt = prompt_template.replace("{{document}}", documents)
temperature = 0.9
top_k = 250
messages = [{"role": "user", "content": [{"text": prompt}]}]
# Base inference parameters to use.
inference_config = {"temperature": temperature, "maxTokens": 512, "topP": 1.0}
# Additional inference parameters to use.
additional_model_fields = {"top_k": top_k}

# Send the message.
response = bedrock_runtime.converse(
    modelId=model_id,
    messages=messages,
    system=[{"text": system_prompt}],
    inferenceConfig=inference_config,
    additionalModelRequestFields=additional_model_fields
)
print(response['output']['message']['content'][0]['text'])
result = response['output']['message']['content'][0]['text']
q_pos = [(a.start(), a.end()) for a in list(re.finditer("Question:", result))]
a_pos = [(a.start(), a.end()) for a in list(re.finditer("Answer:", result))]

Recupere respuestas utilizando las API de la base de conocimientos

Utilizamos las preguntas generadas y recuperamos respuestas de la base de conocimiento mediante la función de recuperación y converse API:

contexts = []
answers = []

for question in questions:
    response = agent_runtime.retrieve(
        knowledgeBaseId=knowledge_base_id,
        retrievalQuery={
            'text': question
        },
        retrievalConfiguration={
            'vectorSearchConfiguration': {
                'numberOfResults': topk
            }
        }
    )
    
    retrieval_results = response['retrievalResults']
    local_contexts = []
    for result in retrieval_results:
        local_contexts.append(result['content']['text'])
    contexts.append(local_contexts)
    combined_docs = "\n".join(local_contexts)
    prompt = llm_prompt_template.replace("{{documents}}", combined_docs)
    prompt = prompt.replace("{{query}}", question)
    temperature = 0.9
    top_k = 250
    messages = [{"role": "user", "content": [{"text": prompt}]}]
    # Base inference parameters to use.
    inference_config = {"temperature": temperature, "maxTokens": 512, "topP": 1.0}
    # Additional inference parameters to use.
    additional_model_fields = {"top_k": top_k}

    # Send the message.
    response = bedrock_runtime.converse(
        modelId=model_id,
        messages=messages,
        inferenceConfig=inference_config,
        additionalModelRequestFields=additional_model_fields
    )
    answers.append(response['output']['message']['content'][0]['text'])

Evaluar la respuesta de RAG utilizando el marco RAGAS

Ahora evaluamos la eficacia del RAG utilizando un marco llamado RAGASEl marco proporciona un conjunto de métricas para evaluar distintas dimensiones. En nuestro ejemplo, evaluamos las respuestas en función de las siguientes dimensiones:

• Relevancia de la respuesta – Esta métrica se centra en evaluar la pertinencia de la respuesta generada para la pregunta planteada. Se asigna una puntuación más baja a las respuestas que están incompletas o contienen información redundante. Esta métrica se calcula utilizando la pregunta y la respuesta, con valores que oscilan entre 0 y 1, donde las puntuaciones más altas indican una mayor relevancia.
• Similitud de respuestas – Evalúa la semejanza semántica entre la respuesta generada y la verdad fundamental. Esta evaluación se basa en la verdad fundamental y la respuesta, con valores que se encuentran dentro del rango de 0 a 1. Una puntuación más alta significa una mejor alineación entre la respuesta generada y la verdad fundamental.
• Relevancia del contexto – Esta métrica mide la relevancia del contexto recuperado, calculada en función de la pregunta y los contextos. Los valores se encuentran en un rango de 0 a 1, donde los valores más altos indican una mayor relevancia.
• Corrección de la respuesta – La evaluación de la exactitud de la respuesta implica medir la precisión de la respuesta generada en comparación con la verdad fundamental. Esta evaluación se basa en la verdad fundamental y la respuesta, con puntuaciones que van de 0 a 1. Una puntuación más alta indica una mayor correspondencia entre la respuesta generada y la verdad fundamental, lo que significa una mayor exactitud.

Informe resumido del enfoque RAG estándar basado en la evaluación RAGAS:

answer_relevancy: 0.9006225160334027

answer_similarity: 0.7400904157096762

answer_correctness: 0.32703043056663855

context_relevancy: 0.024797687553157175

RAG de dos etapas: Recuperar y reclasificar

Ahora que tienes los resultados con el retrieve_and_generate API, exploremos el enfoque de recuperación de dos etapas mediante la extensión del enfoque RAG estándar para integrarlo con un modelo de reclasificación. En el contexto de RAG, los modelos de reclasificación se utilizan después de que el recuperador recupera un conjunto inicial de contextos. El modelo de reclasificación toma la lista de resultados y reclasifica cada uno en función de la similitud entre el contexto y la consulta del usuario. En nuestro ejemplo, utilizamos un modelo de reclasificación poderoso llamado bge-reranker-grandeEl modelo está disponible en Hugging Face Hub y también es gratuito para uso comercial. En el código siguiente, utilizamos la base de conocimientos retrieve API para que podamos obtener el control del contexto y reclasificarlo utilizando el modelo de reclasificación implementado como Amazon SageMaker punto final. Proporcionamos el código de muestra para implementar el modelo de reclasificación en SageMaker en el Repositorio de GitHubA continuación se muestra un fragmento de código que demuestra el proceso de recuperación en dos etapas:

def generate_two_stage_context_answers(bedrock_runtime, 
                                       agent_runtime, 
                                       model_id, 
                                       knowledge_base_id, 
                                       retrieval_topk, 
                                       reranking_model, 
                                       questions, 
                                       rerank_top_k=3):
    contexts = []
    answers = []
    predictor = Predictor(endpoint_name=reranking_model, serializer=JSONSerializer(), deserializer=JSONDeserializer())
    for question in questions:
        retrieval_results = two_stage_retrieval(agent_runtime, knowledge_base_id, question, retrieval_topk, predictor, rerank_top_k)
        local_contexts = []
        documents = []
        for result in retrieval_results:
            local_contexts.append(result)

        contexts.append(local_contexts)
        combined_docs = "\n".join(local_contexts)
        prompt = llm_prompt_template.replace("{{documents}}", combined_docs)
        prompt = prompt.replace("{{query}}", question)
        temperature = 0.9
        top_k = 250
        messages = [{"role": "user", "content": [{"text": prompt}]}]
        inference_config = {"temperature": temperature, "maxTokens": 512, "topP": 1.0}
        additional_model_fields = {"top_k": top_k}
        
        response = bedrock_runtime.converse(
            modelId=model_id,
            messages=messages,
            inferenceConfig=inference_config,
            additionalModelRequestFields=additional_model_fields
        )
        answers.append(response['output']['message']['content'][0]['text'])
    return contexts, answers

Evaluar la respuesta RAG de dos etapas utilizando el marco RAGAS

Evaluamos las respuestas generadas mediante el proceso de recuperación en dos etapas. A continuación, se presenta un informe resumido basado en la evaluación RAGAS:

answer_relevancy: 0.841581671275458

answer_similarity: 0.7961827348349313

answer_correctness: 0.43361356731293665

context_relevancy: 0.06049484724216884

Comparar los resultados

Comparemos los resultados de nuestras pruebas. Como se muestra en la siguiente figura, la API de reclasificación mejora la relevancia del contexto, la exactitud de las respuestas y la similitud de las respuestas, que son importantes para mejorar la precisión del proceso RAG.

Métricas de evaluación de RAG vs recuperación en dos etapas

De manera similar, también medimos la latencia de RAG para ambos enfoques. Los resultados se pueden mostrar en las siguientes métricas y el gráfico correspondiente:

Standard RAG latency: 76.59s

Two Stage Retrieval latency: 312.12s

Métrica de latencia para RAG y proceso de recuperación en dos etapas

En resumen, utilizando un modelo de reordenamiento (tge-reranker-grande) alojado en un ml.m5.xlarge La instancia produce aproximadamente cuatro veces la latencia en comparación con el enfoque RAG estándar. Recomendamos realizar pruebas con diferentes variantes del modelo de reclasificación y tipos de instancia para obtener el rendimiento óptimo para su caso de uso.

Conclusión

En esta publicación, demostramos cómo implementar un proceso de recuperación de dos etapas mediante la integración de un modelo de reclasificación. Exploramos cómo la integración de un modelo de reclasificación con Knowledge Bases para Amazon Bedrock puede proporcionar un mejor rendimiento. Por último, utilizamos RAGAS, un marco de código abierto, para proporcionar métricas de relevancia del contexto, relevancia de las respuestas, similitud de las respuestas y corrección de las respuestas para ambos enfoques.

Pruebe este proceso de recuperación hoy y comparta sus opiniones en los comentarios.

Sobre el Autor

Te Wei es arquitecto de soluciones de aprendizaje automático en AWS. Le apasiona ayudar a los clientes a lograr sus objetivos comerciales mediante soluciones de aprendizaje automático de vanguardia. Fuera del trabajo, disfruta de actividades al aire libre como acampar, pescar y hacer caminatas con su familia.

Nargund de Pallavi es arquitecta de soluciones principal en AWS. En su función como facilitadora de tecnología en la nube, trabaja con los clientes para comprender sus objetivos y desafíos, y brindar orientación prescriptiva para lograr sus objetivos con las ofertas de AWS. Le apasionan las mujeres en la tecnología y es miembro principal de Women in AI/ML en Amazon. Habla en conferencias internas y externas como AWS re:Invent, AWS Summits y seminarios web. Fuera del trabajo, disfruta del voluntariado, la jardinería, el ciclismo y el senderismo.

Li Qingwei es especialista en aprendizaje automático en Amazon Web Services. Obtuvo su doctorado en Investigación de operaciones después de quebrar la cuenta de becas de investigación de su asesor y no entregar el Premio Nobel que prometió. Actualmente ayuda a los clientes de la industria de servicios financieros y seguros a crear soluciones de aprendizaje automático en AWS. En su tiempo libre, le gusta leer y enseñar.

Mani Khanuja es líder tecnológica y especialista en inteligencia artificial generativa, autora del libro Applied Machine Learning and High Performance Computing on AWS y miembro de la junta directiva de Women in Manufacturing Education Foundation. Lidera proyectos de aprendizaje automático en diversos dominios, como visión artificial, procesamiento del lenguaje natural e inteligencia artificial generativa. Da charlas en conferencias internas y externas, como AWS re:Invent, Women in Manufacturing West, seminarios web de YouTube y GHC 23. En su tiempo libre, le gusta salir a correr largas distancias por la playa.