Mitigar alucinaciones a través de la Generación Mejorada por Recuperación utilizando la base de datos de vectores de Pinecone y Llama-2 de Amazon SageMaker JumpStart

Aliviar alucinaciones mediante Generación Mejorada por Recuperación utilizando la base de datos de vectores de Pinecone y Llama-2 de Amazon SageMaker JumpStart

A pesar de la aparentemente imparable adopción de LLMs en diferentes industrias, estos son solo un componente de un ecosistema tecnológico más amplio que impulsa la nueva ola de IA. Muchos casos de uso de IA conversacional requieren LLMs como Llama 2, Flan T5 y Bloom para responder a las consultas de los usuarios. Estos modelos se basan en conocimiento paramétrico para responder preguntas. El modelo aprende este conocimiento durante el entrenamiento y lo codifica en los parámetros del modelo. Para actualizar este conocimiento, debemos volver a entrenar el LLM, lo cual requiere mucho tiempo y dinero.

Afortunadamente, también podemos utilizar conocimiento fuente para informar a nuestros LLMs. El conocimiento fuente es información introducida en el LLM a través de una indicación de entrada. Un enfoque popular para proporcionar conocimiento fuente es la Generación con Recuperación (RAG). Mediante RAG, recuperamos información relevante de una fuente de datos externa y la introducimos en el LLM.

En esta publicación del blog, exploraremos cómo implementar LLMs como Llama-2 utilizando Amazon Sagemaker JumpStart y mantener nuestros LLMs actualizados con información relevante a través de la Generación con Recuperación (RAG) utilizando la base de datos vectorial Pinecone para evitar la Alucinación de IA.

Generación con Recuperación (RAG) en Amazon SageMaker

Pinecone se encargará del componente de recuperación de RAG, pero necesitarás dos componentes críticos adicionales: un lugar para ejecutar la inferencia de LLM y un lugar para ejecutar el modelo de incrustación.

• SetFitABSA Análisis de Sentimiento Basado en Aspectos de Pocas Muestras utilizando SetFit
• Cómo las naciones están perdiendo una carrera global para abordar los daños de la inteligencia artificial.
• Red de robots monitoriza tuberías utilizando sensores de ondas acústicas

Amazon SageMaker Studio es un entorno de desarrollo integrado (IDE) que proporciona una única interfaz visual basada en web donde se puede acceder a herramientas especialmente diseñadas para llevar a cabo todo el desarrollo de aprendizaje automático (ML). Proporciona SageMaker JumpStart, que es un centro de modelos donde los usuarios pueden encontrar, previsualizar y lanzar un modelo específico en su propia cuenta de SageMaker. Proporciona modelos preentrenados, públicamente disponibles y propietarios para una amplia gama de tipos de problemas, incluyendo Modelos Fundamentales.

Amazon SageMaker Studio proporciona el entorno ideal para desarrollar canalizaciones de LLM habilitadas con RAG. En primer lugar, usando la consola de AWS, ve a Amazon SageMaker y crea un dominio de SageMaker Studio y abre un cuaderno de Jupyter Studio.

Prerrequisitos

Completa los siguientes pasos previos necesarios:

1. Configurar Amazon SageMaker Studio.
2. Incorporarse a un dominio de Amazon SageMaker.
3. Registrarse para obtener una base de datos vectorial Pinecone de nivel gratuito.
4. Bibliotecas previas necesarias: SDK de Python de SageMaker, Cliente de Pinecone

Descripción de la solución

Utilizando el cuaderno de SageMaker Studio, primero necesitamos instalar las bibliotecas previas necesarias:

!pip install -qU sagemaker pinecone-client==2.2.1 ipywidgets==7.0.0

Implementación de un LLM

En esta publicación, discutiremos dos enfoques para implementar un LLM. El primero es a través del objeto HuggingFaceModel. Se puede utilizar este enfoque cuando se implementan LLMs (y modelos de incrustación) directamente desde el centro de modelos de Hugging Face.

Por ejemplo, puedes crear una configuración implementable para el modelo google/flan-t5-xl como se muestra en la siguiente captura de pantalla:

import sagemakerfrom sagemaker.huggingface import (HuggingFaceModel, get_huggingface_llm_image_uri)role = sagemaker.get_execution_role()hub_config = {'HF_MODEL_ID':'google/flan-t5-xl', # model_id from hf.co/models'HF_TASK':'text-generation' # NLP task you want to use for predictions# retrieve the llm image urillm_image = get_huggingface_llm_image_uri("huggingface", version="0.8.2"&)huggingface_model = HuggingFaceModel(env=hub_config, role=role, # iam role with permissions to create an Endpoint image_uri=llm_image)

Cuando se implementan modelos directamente desde Hugging Face, inicializa my_model_configuration de la siguiente manera:

• Una configuración env nos indica qué modelo queremos usar y para qué tarea.
• Nuestro rol de ejecución de SageMaker nos da permisos para implementar nuestro modelo.
• Un image_uri es una configuración de imagen específica para implementar LLMs desde Hugging Face.

Alternativamente, SageMaker tiene un conjunto de modelos directamente compatibles con un objeto JumpStartModel más simple. Este modelo admite muchos LLM populares, como Llama 2, que se puede inicializar como se muestra en la siguiente captura de pantalla:

import sagemaker from sagemaker.jumpstart.model import JumpStartModel role = sagemaker.get_execution_role() my_model = JumpStartModel(model_id = "meta-textgeneration-llama-2-7b-f")

Para ambas versiones de my_model, despliégalas como se muestra en la siguiente captura de pantalla:

predictor = my_model.deploy(    initial_instance_count=1, instance_type="ml.g5.4xlarge", endpoint_name="llama-2-generator")

Consulta del LLM pre-entrenado

Con nuestro punto final LLM inicializado, puedes comenzar a realizar consultas. El formato de nuestras consultas puede variar (especialmente entre LLM conversacionales y no conversacionales), pero el proceso es generalmente el mismo. Para el modelo Hugging Face, realiza lo siguiente:

# https://aws.amazon.com/blogs/machine-learning/llama-2-foundation-models-from-meta-are-now-available-in-amazon-sagemaker-jumpstart/prompt = """Responde la siguiente PREGUNTA basada en el CONTEXTO proporcionado. Si no sabes la respuesta y el CONTEXTO no contiene la respuesta, di la verdad "No sé".RESPUESTA:"""carga = {    "inputs":        [        [         {"role": "sistema", "contenido": prompt},         {"role": "usuario", "contenido": pregunta},        ]         ],   "parámetros":{"max_new_tokens": 64, "top_p": 0.9, "temperatura": 0.6, "return_full_text": False}}resultado = predictor.predict(carga, custom_attributes='accept_eula=true')resultado[0]['generation']['content']

Puedes encontrar la solución en el repositorio de GitHub.

La respuesta generada que estamos recibiendo aquí no tiene mucho sentido, es una alucinación.

Proporcionando contexto adicional al LLM

Llama 2 intenta responder nuestra pregunta basándose únicamente en el conocimiento paramétrico interno. Claramente, los parámetros del modelo no almacenan conocimiento sobre qué instancias podemos usar con el entrenamiento de spot gestionado en SageMaker.

Para responder esta pregunta correctamente, debemos usar conocimiento fuente. Es decir, proporcionamos información adicional al LLM a través del prompt. Añadamos esa información directamente como contexto adicional para el modelo.

contexto = """El entrenamiento de spots gestionado se puede usar con todas las instancias admitidas en Amazon SageMaker. El entrenamiento de spots gestionado se admite en todas las regiones de AWS donde actualmente está disponible Amazon SageMaker."""plantilla_prompt = """Responde la siguiente PREGUNTA basada en el CONTEXTO proporcionado. Si no sabes la respuesta y el CONTEXTO no contiene la respuesta, di la verdad "No sé".CONTEXTO:{contexto}RESPUESTA:"""texto_entrada = plantilla_prompt.replace("{contexto}", contexto).replace("{pregunta}", pregunta)carga = {    "inputs":        [        [         {"role": "sistema", "contenido": texto_entrada},         {"role": "usuario", "contenido": pregunta},        ]         ],   "parámetros":{"max_new_tokens": 64, "top_p": 0.9, "temperatura": 0.6, "return_full_text": False}}resultado = predictor.predict(carga, custom_attributes='accept_eula=true')texto_generado = resultado[0]['generation']['content']print(f"[Entrada]: {pregunta}\n[Salida]: {texto_generado}")[Entrada]: ¿Qué instancias puedo usar con el entrenamiento de spot gestionado en SageMaker?[Salida]:  Basándonos en el contexto proporcionado, puedes usar el entrenamiento de spot gestionado con todas las instancias admitidas en Amazon SageMaker. Por lo tanto, la respuesta es:Todas las instancias admitidas en Amazon SageMaker.

Ahora vemos la respuesta correcta a la pregunta; ¡eso fue fácil! Sin embargo, es poco probable que un usuario inserte contextos en sus prompts, ya que ya conocen la respuesta a su pregunta.

En lugar de insertar manualmente un solo contexto, identifica automáticamente información relevante de una base de datos de información más extensa. Para eso, necesitarás Generación Con Mejora de Recuperación.

Generación aumentada por búsqueda

Con la Generación Aumentada por Búsqueda, puedes codificar una base de datos de información en un espacio vectorial donde la proximidad entre vectores representa su relevancia/similitud semántica. Con este espacio vectorial como base de conocimiento, puedes convertir una nueva consulta de usuario, codificarla en el mismo espacio vectorial y recuperar los registros más relevantes previamente indexados.

Después de recuperar estos registros relevantes, selecciona algunos de ellos e inclúyelos en el texto de entrada del LLM como contexto adicional, proporcionando al LLM conocimiento fuente altamente relevante. Este es un proceso de dos pasos donde:

• La indexación llena el índice vectorial con información de un conjunto de datos.
• La recuperación ocurre durante una consulta y es donde recuperamos información relevante del índice vectorial.

Ambos pasos requieren un modelo de incrustación para traducir nuestro texto plano legible por humanos en un espacio vectorial semántico. Utiliza el transformador de oraciones MiniLM altamente eficiente de Hugging Face, como se muestra en la siguiente captura de pantalla. Este modelo no es un LLM y, por lo tanto, no se inicializa de la misma manera que nuestro modelo Llama 2.

hub_config = {    "HF_MODEL_ID": "sentence-transformers/all-MiniLM-L6-v2",  # model_id from hf.co/models    "HF_TASK": "feature-extraction",}huggingface_model = HuggingFaceModel(    env=hub_config,    role=role,    transformers_version="4.6",  # transformers version used    pytorch_version="1.7",  # pytorch version used    py_version="py36",  # python version of the DLC)

En el hub_config, especifica el ID del modelo como se muestra en la captura de pantalla de arriba, pero para la tarea, utiliza “feature-extraction” porque estamos generando incrustaciones vectoriales y no texto como en nuestro LLM. A continuación, inicializa la configuración del modelo con HuggingFaceModel como antes, pero esta vez sin la imagen del LLM y con algunos parámetros de versión.

encoder = huggingface_model.deploy(    initial_instance_count=1, instance_type="ml.t2.large", endpoint_name="minilm-embedding")

Puedes implementar el modelo nuevamente con deploy, utilizando la instancia más pequeña (solo CPU) de ml.t2.large. El modelo MiniLM es pequeño, por lo que no requiere mucha memoria y no necesita una GPU, ya que puede crear rápidamente incrustaciones incluso en una CPU. Si lo prefieres, puedes ejecutar el modelo más rápido en una GPU.

Para crear incrustaciones, utiliza el método predict y pasa una lista de contextos para codificar a través de la clave inputs, como se muestra:

out = encoder.predict({"inputs": ["algún texto aquí", "algo más de texto aquí también"]})

Se pasan dos contextos de entrada, devolviendo dos incrustaciones de vector de contexto, como se muestra:

len(out)

2

La dimensionalidad de incrustación del modelo MiniLM es de 384, lo que significa que cada incrustación de vector que MiniLM produce debe tener una dimensionalidad de 384. Sin embargo, al observar la longitud de nuestras incrustaciones, verás lo siguiente:

len(out[0]), len(out[1])

(8, 8)

Las dos listas contienen ocho elementos cada una. MiniLM primero procesa el texto en un paso de tokenización. Esta tokenización transforma nuestro texto plano legible por humanos en una lista de ID de tokens legibles por el modelo. En las características de salida del modelo, puedes ver las incrustaciones a nivel de token. Una de estas incrustaciones muestra la dimensionalidad esperada de 384, como se muestra:

len(out[0][0])

384

Transforma estas incrustaciones a nivel de token en incrustaciones a nivel de documento utilizando los valores promedio en cada dimensión del vector, como se muestra en la siguiente ilustración.

Operación de agrupación promedio para obtener un solo vector de 384 dimensiones.

import numpy as np embeddings = np.mean(np.array(out), axis=1)embeddings.shape(2, 384)

Con dos incrustaciones de vectores de 384 dimensiones, una para cada texto de entrada. Para facilitar nuestras vidas, envolvemos el proceso de codificación en una única función como se muestra en la siguiente captura de pantalla:

from typing import Listdef embed_docs(docs: List[str]) -> List[List[float]]:    out = encoder.predict({"inputs": docs})    embeddings = np.mean(np.array(out), axis=1)    return embeddings.tolist()

Descargar el conjunto de datos

Descargue las preguntas frecuentes de Amazon SageMaker como base de conocimientos para obtener los datos que contienen tanto las columnas de pregunta como de respuesta.

Descarga de las preguntas frecuentes de Amazon SageMaker

Cuando realice la búsqueda, busque solo respuestas, de modo que pueda omitir la columna de pregunta. Ver cuaderno para más detalles.

Nuestro conjunto de datos y el proceso de incrustación están listos. Ahora todo lo que necesitamos es algún lugar para almacenar esas incrustaciones.

Indexación

La base de datos vectorial de Pinecone almacena incrustaciones de vectores y las busca de manera eficiente a gran escala. Para crear una base de datos, necesitará una clave API gratuita de Pinecone.

import pineconeimport os# agregar clave API de Pinecone desde app.pinecone.ioapi_key = os.environ.get("PINECONE_API_KEY") or "TU_CLAVE_API"# configurar ambiente Pinecone - buscar junto a la clave API en la consolaenv = os.environ.get("PINECONE_ENVIRONMENT") or "TU_AMBIENTE"pinecone.init(api_key=api_key, environment=env)

Después de haber conectado a la base de datos vectorial de Pinecone, cree un único índice vectorial (similar a una tabla en bases de datos tradicionales). Nombre el índice retrieval-augmentation-aws y alinee los parámetros dimension y metric del índice con los requeridos por el modelo de incrustación (MiniLM en este caso).

import timeindex_name = "retrieval-augmentation-aws"if index_name in pinecone.list_indexes():    pinecone.delete_index(index_name)pinecone.create_index(name=index_name, dimension=embeddings.shape[1], metric="cosine")# esperar a que el índice termine la inicializaciónwhile not pinecone.describe_index(index_name).status["ready"]:    time.sleep(1)

Para comenzar a insertar los datos, ejecute lo siguiente:

from tqdm.auto import tqdmbatch_size = 2  # puede incrementarse pero se necesita un tamaño de instancia más grande si no se agota la memoria de la instanciavector_limit = 1000answers = df_knowledge[:vector_limit]index = pinecone.Index(index_name)for i in tqdm(range(0, len(answers), batch_size)):    # encontrar final del lote    i_end = min(i + batch_size, len(answers))    # crear lotes de IDs    ids = [str(x) for x in range(i, i_end)]    # crear lotes de metadatos    metadatas = [{"text": text} for text in answers["Answer"][i:i_end]]    # crear incrustaciones    texts = answers["Answer"][i:i_end].tolist()    embeddings = embed_docs(texts)    # crear lista de registros para insertar o actualizar    records = zip(ids, embeddings, metadatas)    # insertar o actualizar en Pinecone    index.upsert(vectors=records)

Puede comenzar a realizar consultas en el índice con la pregunta mencionada anteriormente en esta publicación.

# extraer incrustaciones para las preguntasquery_vec = embed_docs(question)[0]# consultar pineconeres = index.query(query_vec, top_k=1, include_metadata=True)# mostrar los resultadosres{'matches': [{'id': '90','metadata': {'text': 'Managed Spot Training can be used with all ''instances supported in Amazon ''SageMaker.\r\n'},'score': 0.881181657,'values': []}],'namespace': ''}

La salida anterior muestra que estamos devolviendo contextos relevantes para ayudarnos a responder nuestra pregunta. Dado que top_k = 1, index.query devolvió el resultado principal junto con los metadatos que indican: “Managed Spot Training se puede utilizar con todas las instancias admitidas en Amazon”.

Aumentando la indicación

Usa los contextos recuperados para aumentar la indicación y decide una cantidad máxima de contexto para alimentar en el LLM. Utiliza el límite de 1000 caracteres para agregar iterativamente cada contexto retornado a la indicación hasta que excedas la longitud del contenido.

Aumentando la indicación

Alimenta la variable context_str en la indicación del LLM como se muestra en la siguiente captura de pantalla:

carga = crear_carga(pregunta, context_str)resultados = predictor.predecir(carga, atributos_personalizados='aceptar_eula=true')texto_generado = resultados[0]['generación']['contenido']print(f"[Entrada]: {pregunta}\n[Salida]: {texto_generado}")

[Entrada]: ¿Qué instancias puedo usar con Managed Spot Training en SageMaker?[Salida]: Basado en el contexto proporcionado, puedes usar Managed Spot Training con todas las instancias admitidas en Amazon SageMaker. Por lo tanto, la respuesta es: todas las instancias admitidas en Amazon SageMaker.

La lógica funciona, así que envuélvela en una única función para mantener las cosas ordenadas.

def consulta_rag(pregunta: str) -> str:    # crear el vector de consulta    vector_consulta = incrustar_documentos(pregunta)[0]    # consultar Pinecone    res = índice.consultar(vector_consulta, top_k=5, incluir_metadatos=True)    # obtener contextos    contextos = [coincidencia.metadatos["texto"] for coincidencia in res.coincidencias]    # construir la cadena de múltiples contextos    context_str = construir_contexto(contextos=contextos)    # crear nuestra indicación de recuperación aumentada    carga = crear_carga(pregunta, context_str)    # hacer predicción    resultados = predictor.predecir(carga, atributos_personalizados='aceptar_eula=true')    return resultados[0]["generación"]["contenido"]

Ahora puedes hacer preguntas como las que se muestran a continuación:

consulta_rag("¿SageMaker admite instancias spot?")' Sí, Amazon SageMaker admite instancias spot para managed spot training. Según el contexto proporcionado, Managed Spot Training se puede utilizar con todas las instancias admitidas en Amazon SageMaker, y Managed Spot Training es compatible en todas las regiones de AWS donde actualmente está disponible Amazon SageMaker.\n\nPor lo tanto, la respuesta a tu pregunta es:\n\nSí, SageMaker admite instancias spot en todas las regiones donde está disponible Amazon SageMaker.'

Limpieza

Para dejar de incurrir en cargos no deseados, elimina el modelo y el punto de enlace.

encoder.eliminar_modelo()encoder.eliminar_punto_enlace()

Conclusión

En esta publicación, te presentamos RAG con LLM de acceso abierto en SageMaker. También mostramos cómo implementar modelos de Amazon SageMaker Jumpstart con Llama 2, LLM de Hugging Face con Flan T5 y modelos de incrustación con MiniLM.

Implementamos un proceso RAG de extremo a extremo utilizando nuestros modelos de acceso abierto y un índice vectorial de Pinecone. Con esto, mostramos cómo minimizar las alucinaciones, mantener actualizados los conocimientos del LLM y, en última instancia, mejorar la experiencia del usuario y la confianza en nuestros sistemas.

Para ejecutar este ejemplo por tu cuenta, clona este repositorio de GitHub y sigue los pasos anteriores utilizando el cuaderno de preguntas y respuestas en GitHub.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!