Construye un chatbot contextual para servicios financieros utilizando Amazon SageMaker JumpStart, Llama 2 y Amazon OpenSearch Serverless con Vector Engine.

Construye un chatbot contextual para servicios financieros con Amazon SageMaker JumpStart, Llama 2 y Amazon OpenSearch Serverless usando Vector Engine.

La industria de servicios financieros (FinServ) tiene requisitos únicos de IA generativa relacionados con datos específicos del dominio, seguridad de datos, controles regulatorios y normas de cumplimiento de la industria. Además, los clientes buscan opciones para seleccionar el modelo de aprendizaje automático (ML) más eficiente y rentable y la capacidad de realizar la personalización necesaria (ajuste fino) para adaptarse a sus casos de uso empresariales. Amazon SageMaker JumpStart es ideal para casos de uso de IA generativa para clientes de FinServ porque proporciona los controles de seguridad de datos necesarios y cumple con los requisitos de las normas de cumplimiento.

En esta publicación, demostraremos tareas de respuesta a preguntas utilizando un enfoque basado en Retrieval Augmented Generation (RAG) con grandes modelos de lenguaje (LLMs) en SageMaker JumpStart utilizando un caso de uso simple en el ámbito financiero. RAG es un marco para mejorar la calidad de la generación de texto combinando un LLM con un sistema de recuperación de información (IR). El texto generado por el LLM y el sistema de IR recuperan información relevante de una base de conocimientos. La información recuperada se utiliza luego para aumentar la entrada del LLM, lo que puede ayudar a mejorar la precisión y relevancia del texto generado por el modelo. Se ha demostrado que RAG es eficaz para una variedad de tareas de generación de texto, como preguntas y respuestas y resúmenes. Es un enfoque prometedor para mejorar la calidad y precisión de los modelos de generación de texto.

Ventajas de usar SageMaker JumpStart

Con SageMaker JumpStart, los profesionales de ML pueden elegir entre una amplia selección de modelos de vanguardia en casos de uso como redacción de contenido, generación de imágenes, generación de código, respuesta a preguntas, redacción, resúmenes, clasificación, recuperación de información y más. Los profesionales de ML pueden implementar modelos en instancias dedicadas de Amazon SageMaker desde un entorno aislado de red y personalizar los modelos utilizando SageMaker para el entrenamiento y la implementación del modelo.

SageMaker JumpStart es ideal para casos de uso de IA generativa para clientes de FinServ porque ofrece lo siguiente:

• Construye soluciones de IDP bien diseñadas con una lente personalizada – Parte 1 Excelencia operativa
• Científicos convierten a las carpas invasoras en traidoras.
• El debate sobre la seguridad de la IA está dividiendo Silicon Valley

• Capacidades de personalización – SageMaker JumpStart proporciona cuadernos de ejemplo y publicaciones detalladas para orientación paso a paso sobre la adaptación de dominio de los modelos fundamentales. Puede seguir estos recursos para el ajuste fino, la adaptación de dominio y la instrucción de modelos fundamentales o para construir aplicaciones basadas en RAG.
• Seguridad de datos – Garantizar la seguridad de los datos de carga de inferencia es primordial. Con SageMaker JumpStart, puede implementar modelos en aislamiento de red con provisión de puntos de conexión de un solo arrendatario. Además, puede administrar el control de acceso a modelos seleccionados a través de la capacidad de modelo privado, en línea con los requisitos individuales de seguridad.
• Controles regulatorios y cumplimientos – El cumplimiento de normas como HIPAA BAA, SOC123, PCI y HITRUST CSF es una característica clave de SageMaker, que garantiza la alineación con el riguroso panorama regulatorio del sector financiero.
• Opciones de modelos – SageMaker JumpStart ofrece una selección de modelos de ML de vanguardia que consistentemente se encuentran entre los mejores en los benchmarks reconocidos por la industria. Estos incluyen, entre otros, Llama 2, Falcon 40B, AI21 J2 Ultra, AI21 Summarize, Hugging Face MiniLM y modelos BGE.

En esta publicación, exploramos la construcción de un chatbot contextual para organizaciones de servicios financieros utilizando una arquitectura RAG con el modelo fundamental Llama 2 y el modelo de embeddings Hugging Face GPTJ-6B-FP16, ambos disponibles en SageMaker JumpStart. También utilizamos Vector Engine para Amazon OpenSearch Serverless (actualmente en vista previa) como el almacén de datos vectoriales para almacenar los embeddings.

Limitaciones de los modelos de lenguaje grandes

Los LLM se han entrenado con grandes volúmenes de datos no estructurados y sobresalen en la generación de texto general. A través de este entrenamiento, los LLM adquieren y almacenan conocimientos factuales. Sin embargo, los LLM listos para usar presentan limitaciones:

• Su entrenamiento sin conexión los hace desconocedores de información actualizada.
• Su entrenamiento en datos predominantemente generalizados disminuye su eficacia en tareas específicas del dominio. Por ejemplo, una empresa financiera podría preferir que su bot de preguntas y respuestas obtenga respuestas de sus últimos documentos internos, asegurando precisión y cumplimiento con sus reglas comerciales.
• Su dependencia de la información incrustada compromete la interpretabilidad.

Para utilizar datos específicos en LLMs, existen tres métodos prevalecientes:

• Embeber datos dentro de las indicaciones del modelo, permitiéndole utilizar este contexto durante la generación de resultados. Esto puede ser de cero disparos (sin ejemplos), poco disparos (ejemplos limitados) o muchos disparos (ejemplos abundantes). Tal indicación contextual dirige a los modelos hacia resultados más matizados.
• Ajustar finamente el modelo utilizando pares de indicaciones y completados.
• RAG, que recupera datos externos (no paramétricos) e integra estos datos en las indicaciones, enriqueciendo el contexto.

Sin embargo, el primer método se enfrenta a restricciones del modelo en cuanto al tamaño del contexto, lo que dificulta la introducción de documentos extensos y posiblemente aumenta los costos. El enfoque de ajuste fino, aunque potente, requiere muchos recursos, especialmente con datos externos en constante evolución, lo que provoca despliegues demorados y mayores costos. RAG combinado con LLMs ofrece una solución a las limitaciones mencionadas anteriormente.

Generación Aumentada de Recuperación

RAG recupera datos externos (no paramétricos) e integra estos datos en las indicaciones de ML, enriqueciendo el contexto. Lewis et al. presentaron los modelos RAG en 2020, conceptualizándolos como una fusión de un modelo pre-entrenado de secuencia a secuencia (memoria paramétrica) y un índice de vectores densos de Wikipedia (memoria no paramétrica) accesible a través de un recuperador neuronal.

Así es como opera RAG:

• Fuentes de datos – RAG puede extraer de diversas fuentes de datos, incluidos repositorios de documentos, bases de datos o APIs.
• Formato de datos – Tanto la consulta del usuario como los documentos se transforman en un formato adecuado para las comparaciones de relevancia.
• Embebidos – Para facilitar esta comparación, la consulta y la colección de documentos (o biblioteca de conocimiento) se transforman en incrustaciones numéricas utilizando modelos de lenguaje. Estas incrustaciones encapsulan numéricamente los conceptos textuales.
• Búsqueda de relevancia – La incrustación de la consulta del usuario se compara con las incrustaciones de la colección de documentos, identificando texto relevante a través de una búsqueda de similitud en el espacio de incrustación.
• Enriquecimiento del contexto – El texto relevante identificado se agrega a la indicación original del usuario, mejorando así su contexto.
• Procesamiento de LLM – Con el contexto enriquecido, la indicación se alimenta al LLM, que, debido a la inclusión de datos externos pertinentes, produce salidas relevantes y precisas.
• Actualizaciones asincrónicas – Para asegurarse de que los documentos de referencia se mantengan actualizados, se pueden actualizar de forma asincrónica junto con sus representaciones de incrustación. Esto garantiza que las respuestas futuras del modelo estén basadas en la información más reciente, garantizando precisión.

En esencia, RAG ofrece un método dinámico para infundir LLMs con información relevante en tiempo real, asegurando la generación de resultados precisos y oportunos.

El siguiente diagrama muestra el flujo conceptual de cómo utilizar RAG con LLMs.

Resumen de la solución

Los siguientes pasos son necesarios para crear un chatbot de preguntas y respuestas contextuales para una aplicación de servicios financieros:

1. Utilizar el modelo de incrustación SageMaker JumpStart GPT-J-6B para generar incrustaciones para cada documento PDF en el directorio de carga de Amazon Simple Storage Service (Amazon S3).
2. Identificar documentos relevantes utilizando los siguientes pasos:
   • Generar una incrustación para la consulta del usuario utilizando el mismo modelo.
   • Utilizar OpenSearch Serverless con la función de motor de vector para buscar los K principales índices de documentos más relevantes en el espacio de incrustación.
   • Recuperar los documentos correspondientes utilizando los índices identificados.
3. Combinar los documentos recuperados como contexto con la indicación y pregunta del usuario. Enviar esto al LLM de SageMaker para generar una respuesta.

Utilizamos LangChain, un marco popular, para orquestar este proceso. LangChain está específicamente diseñado para fortalecer aplicaciones impulsadas por LLMs, ofreciendo una interfaz universal para varios LLMs. Simplifica la integración de múltiples LLMs, asegurando una persistencia de estado sin problemas entre llamadas. Además, mejora la eficiencia del desarrollador con características como plantillas de indicaciones personalizables, agentes de creación de aplicaciones comprensivas e índices especializados para búsqueda y recuperación. Para una comprensión más detallada, consulte la documentación de LangChain aquí.

Prerrequisitos

Necesitas los siguientes prerrequisitos para construir nuestro chatbot de conciencia contextual:

• Una cuenta de AWS con los permisos apropiados de Gestión de Identidad y Acceso AWS (IAM).
• Un dominio y un usuario de Amazon SageMaker Studio. Para obtener instrucciones de configuración, consulta Introducción a Amazon SageMaker Studio usando la configuración rápida.
• Una colección de OpenSearch Serverless.
• Un rol de ejecución de SageMaker con acceso a OpenSearch Serverless.

Para obtener instrucciones sobre cómo configurar un motor vectorial de OpenSearch Serverless, consulta Presentación del motor vectorial para Amazon OpenSearch Serverless, ahora en versión preliminar.

Para obtener una descripción detallada de la siguiente solución, clona el repositorio de GitHub y consulta el cuaderno Jupyter.

Implementa los modelos de ML utilizando SageMaker JumpStart

Para implementar los modelos de ML, sigue los siguientes pasos:

1. Implementa el modelo Llama 2 LLM desde SageMaker JumpStart:

   from sagemaker.jumpstart.model import JumpStartModelllm_model = JumpStartModel(model_id = "meta-textgeneration-llama-2-7b-f")llm_predictor = llm_model.deploy()llm_endpoint_name = llm_predictor.endpoint_name

2. Implementa el modelo de embeddings de GPT-J:

   embeddings_model = JumpStartModel(model_id = "huggingface-textembedding-gpt-j-6b-fp16")embed_predictor = embeddings_model.deploy()embeddings_endpoint_name = embed_predictor.endpoint_name

Divide los datos y crea un objeto de embeddings de documentos

En esta sección, dividirás los datos en documentos más pequeños. La división es una técnica para dividir textos grandes en fragmentos más pequeños. Es un paso esencial porque optimiza la relevancia de la búsqueda para nuestro modelo RAG, lo que a su vez mejora la calidad del chatbot. El tamaño del fragmento depende de factores como el tipo de documento y el modelo utilizado. Se ha seleccionado un tamaño de fragmento de 1600 porque es el tamaño aproximado de un párrafo. A medida que los modelos mejoran, el tamaño de su ventana de contexto aumentará, lo que permitirá tamaños de fragmentos más grandes.

Consulta el cuaderno Jupyter en el repositorio de GitHub para obtener la solución completa.

1. Amplía la clase SageMakerEndpointEmbeddings de LangChain para crear una función de embeddings personalizada que utiliza el endpoint de SageMaker gpt-j-6b-fp16 que creaste anteriormente (como parte de la implementación del modelo de embeddings):

   from langchain.embeddings import SagemakerEndpointEmbeddingsfrom langchain.embeddings.sagemaker_endpoint import EmbeddingsContentHandlerlogger = logging.getLogger(__name__)# amplía la clase SagemakerEndpointEmbeddings de langchain para proporcionar una función de embedding personalizadaclass SagemakerEndpointEmbeddingsJumpStart(SagemakerEndpointEmbeddings):    def embed_documents(        self, texts: List[str], chunk_size: int = 1    ) → List[List[float]]:        """Compute doc embeddings using a SageMaker Inference Endpoint.         Args:            texts: The list of texts to embed.            chunk_size: The chunk size defines how many input texts will                be grouped together as request. If None, will use the                chunk size specified by the class.        Returns:            List of embeddings, one for each text.        """        results = []        _chunk_size = len(texts) if chunk_size > len(texts) else chunk_size        st = time.time()        for i in range(0, len(texts), _chunk_size):            response = self._embedding_func(texts[i : i + _chunk_size])            results.extend(response)        time_taken = time.time() - st        logger.info(            f"got results for {len(texts)} in {time_taken}s, length of embeddings list is {len(results)}"        )        print(            f"got results for {len(texts)} in {time_taken}s, length of embeddings list is {len(results)}"        )        return results# clase para serializar/deserializar solicitudes/respuestas del modelo de embeddingsclass ContentHandler(EmbeddingsContentHandler):    content_type = "application/json"    accepts = "application/json"     def transform_input(self, prompt: str, model_kwargs={}) → bytes:         input_str = json.dumps({"text_inputs": prompt, **model_kwargs})        return input_str.encode("utf-8")     def transform_output(self, output: bytes) → str:         response_json = json.loads(output.read().decode("utf-8"))        embeddings = response_json["embedding"]        if len(embeddings) == 1:            return [embeddings[0]]        return embeddingsdef create_sagemaker_embeddings_from_js_model(    embeddings_endpoint_name: str, aws_region: str) → SagemakerEndpointEmbeddingsJumpStart:     content_handler = ContentHandler()    embeddings = SagemakerEndpointEmbeddingsJumpStart(        endpoint_name=embeddings_endpoint_name,        region_name=aws_region,        content_handler=content_handler,    )    return embeddings

2. Crea el objeto de embeddings y agrupa la creación de los embeddings de documentos:

   embeddings = create_sagemaker_embeddings_from_js_model(embeddings_endpoint_name, aws_region)

3. Estos embeddings se almacenan en el motor de vectores utilizando OpenSearchVectorSearch de LangChain. Almacena estos embeddings en la siguiente sección. Almacena el embedding del documento en OpenSearch Serverless. Ahora estás listo para iterar sobre los documentos divididos, crear los embeddings y almacenar estos embeddings en el índice vectorial de OpenSearch Serverless creado en las colecciones de búsqueda vectorial. Mira el siguiente código:

   docsearch = OpenSearchVectorSearch.from_texts(texts = [d.page_content for d in docs],embedding=embeddings,opensearch_url=[{'host': _aoss_host, 'port': 443}],http_auth=awsauth,timeout = 300,use_ssl = True,verify_certs = True,connection_class = RequestsHttpConnection,index_name=_aos_index)

Preguntas y respuestas sobre documentos

Hasta ahora, has dividido un documento grande en varios más pequeños, creado embeddings vectoriales y los has almacenado en un motor vectorial. Ahora puedes responder preguntas relacionadas con estos datos de documentos. Debido a que has creado un índice sobre los datos, puedes realizar una búsqueda semántica; de esta manera, solo se pasan al modelo de lenguaje elástico (LLM, por sus siglas en inglés) los documentos más relevantes necesarios para responder la pregunta. Esto te permite ahorrar tiempo y dinero al pasar solo los documentos relevantes al LLM. Para obtener más detalles sobre cómo usar cadenas de documentos, consulta el enlace Documentos.

Completa los siguientes pasos para responder preguntas utilizando los documentos:

1. Para usar el punto de enlace de SageMaker LLM con LangChain, utiliza langchain.llms.sagemaker_endpoint.SagemakerEndpoint, que abstrae el punto de enlace de SageMaker LLM. Realiza una transformación para la solicitud y la respuesta como se muestra en el siguiente código para la integración de SageMaker LLM de LangChain. Ten en cuenta que es posible que debas ajustar el código en ContentHandler según el contenido_type y el formato de aceptación del modelo LLM que elijas usar.

   content_type = "application/json"accepts = "application/json"def transform_input(self, prompt: str, model_kwargs: dict) → bytes:        payload = {            "inputs": [                [                    {                        "role": "system",                        "content": prompt,                    },                    {"role": "user", "content": prompt},                ],            ],            "parameters": {                "max_new_tokens": 1000,                "top_p": 0.9,                "temperature": 0.6,            },        }        input_str = json.dumps(            payload,        )        return input_str.encode("utf-8")def transform_output(self, output: bytes) → str:    response_json = json.loads(output.read().decode("utf-8"))    content = response_json[0]["generation"]["content"]    return contentcontent_handler = ContentHandler()sm_jumpstart_llm=SagemakerEndpoint(        endpoint_name=llm_endpoint_name,        region_name=aws_region,        model_kwargs={"max_new_tokens": 300},        endpoint_kwargs={"CustomAttributes": "accept_eula=true"},        content_handler=content_handler,    )

Ahora estás listo para interactuar con el documento financiero.

1. Utiliza la siguiente plantilla de consulta y el prompt para hacer preguntas sobre el documento:

   from langchain import PromptTemplate, SagemakerEndpointfrom langchain.llms.sagemaker_endpoint import LLMContentHandlerquery = "Resuma el informe de ganancias y también para qué año es el informe"prompt_template = """Utilice solo el contexto para responder la pregunta al final. {context} Pregunta: {question}Respuesta:"""prompt = PromptTemplate(    template=prompt_template, input_variables=["context", "question"])  class ContentHandler(LLMContentHandler):    content_type = "application/json"    accepts = "application/json"    def transform_input(self, prompt: str, model_kwargs: dict) → bytes:        payload = {            "inputs": [                [                    {                        "role": "system",                        "content": prompt,                    },                    {"role": "user", "content": prompt},                ],            ],            "parameters": {                "max_new_tokens": 1000,                "top_p": 0.9,                "temperature": 0.6,            },        }        input_str = json.dumps(            payload,        )        return input_str.encode("utf-8")     def transform_output(self, output: bytes) → str:        response_json = json.loads(output.read().decode("utf-8"))        content = response_json[0]["generation"]["content"]        return contentcontent_handler = ContentHandler() chain = load_qa_chain(    llm=SagemakerEndpoint(        endpoint_name=llm_endpoint_name,        region_name=aws_region,        model_kwargs={"max_new_tokens": 300},        endpoint_kwargs={"CustomAttributes": "accept_eula=true"},        content_handler=content_handler,    ),    prompt=prompt,)sim_docs = docsearch.similarity_search(query, include_metadata=False)chain({"input_documents": sim_docs, "question": query}, return_only_outputs=True)

Limpieza

Para evitar incurrir en costos futuros, elimina los puntos de enlace de inferencia de SageMaker que creaste en este notebook. Puedes hacerlo ejecutando lo siguiente en tu notebook de SageMaker Studio:

# Borrar LLMllm_predictor.delete_model()llm_predictor.delete_predictor(delete_endpoint_config=True)# Borrar modelo de Embeddingsembed_predictor.delete_model()embed_predictor.delete_predictor(delete_endpoint_config=True)

Si ha creado una colección sin servidor de OpenSearch para este ejemplo y ya no la necesita, puede eliminarla a través de la consola de OpenSearch sin servidor.

Conclusión

En esta publicación, discutimos cómo utilizar RAG como enfoque para proporcionar contexto específico del dominio a LLMs. Mostramos cómo utilizar SageMaker JumpStart para construir un chatbot contextual basado en RAG para una organización de servicios financieros utilizando Llama 2 y OpenSearch sin servidor con un motor de vectores como almacén de datos vectoriales. Este método perfecciona la generación de texto utilizando Llama 2 al obtener dinámicamente un contexto relevante. ¡Estamos emocionados de ver cómo traes tus datos personalizados e innovas con esta estrategia basada en RAG en SageMaker JumpStart!

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