La industria de servicios financieros (FinServ) tiene requisitos únicos de IA generativa relacionados con datos de dominios específicos, seguridad de datos, controles regulatorios y estándares de cumplimiento de la industria. Además, los clientes buscan opciones para seleccionar el modelo de aprendizaje automático (ML) más eficaz y rentable y la capacidad de realizar la personalización necesaria (ajustes finos) para adaptarse a sus casos de uso empresarial. JumpStart de Amazon SageMaker 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 los estándares de cumplimiento.

En esta publicación, demostramos tareas de respuesta a preguntas utilizando un enfoque basado en recuperación de generación aumentada (RAG) con modelos de lenguaje grandes (LLM) en SageMaker JumpStart utilizando un caso de uso de dominio financiero simple. 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 LLM genera texto y el sistema IR recupera 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 la respuesta a preguntas y el resumen. Es un enfoque prometedor para mejorar la calidad y precisión de los modelos de generación de texto.

Ventajas de utilizar SageMaker JumpStart

Con SageMaker JumpStart, los profesionales del aprendizaje automático pueden elegir entre una amplia selección de modelos de última generación para casos de uso como redacción de contenido, generación de imágenes, generación de código, respuesta a preguntas, redacción, resumen, clasificación, recuperación de información y más. Los profesionales del aprendizaje automático pueden implementar modelos básicos en sitios dedicados. Amazon SageMaker instancias de un entorno de red aislado y personalice los modelos con SageMaker para el entrenamiento y la implementación de modelos.

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

• Capacidades de personalización – SageMaker JumpStart proporciona cuadernos de ejemplo y publicaciones detalladas para obtener orientación paso a paso sobre la adaptación del dominio de los modelos básicos. Puede seguir estos recursos para realizar ajustes, adaptación de dominios e instrucción de modelos básicos o para crear aplicaciones basadas en RAG.
• Seguridad de los datos – Garantizar la seguridad de los datos de la carga útil de inferencia es primordial. Con SageMaker JumpStart, puede implementar modelos en aislamiento de red con provisión de punto final de inquilino único. Además, puede gestionar el control de acceso a modelos seleccionados a través de la capacidad del centro de modelos privado, alineándose con los requisitos de seguridad individuales.
• Controles y cumplimientos regulatorios – El cumplimiento de estándares como HIPAA BAA, SOC123, PCI y HITRUST CSF es una característica central de SageMaker, que garantiza la alineación con el riguroso panorama regulatorio del sector financiero.
• Opciones de modelo – SageMaker JumpStart ofrece una selección de modelos de aprendizaje automático de última generación que se ubican constantemente entre los mejores en los puntos de referencia HELM reconocidos en la industria. Estos incluyen, entre otros, los modelos Llama 2, Falcon 40B, AI21 J2 Ultra, AI21 Summarize, Hugging Face MiniLM y 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 básico Llama 2 y el Abrazando la cara GPTJ-6B-FP16 modelo de incrustaciones, ambos disponibles en SageMaker JumpStart. También usamos motor vectorial para Amazon OpenSearch sin servidor (actualmente en vista previa) como almacén de datos vectoriales para almacenar incrustaciones.

Limitaciones de los modelos de lenguaje grandes

Los LLM han sido capacitados en grandes volúmenes de datos no estructurados y se destacan en la generación de textos generales. A través de esta formación, los LLM adquieren y almacenan conocimientos fácticos. Sin embargo, los LLM disponibles en el mercado presentan limitaciones:

• Su formación fuera de línea les impide disponer de información actualizada.
• Su formación sobre datos predominantemente generalizados disminuye su eficacia en tareas de dominios específicos. Por ejemplo, una empresa financiera podría preferir que su robot de preguntas y respuestas obtenga respuestas de sus documentos internos más recientes, garantizando la precisión y el cumplimiento de sus reglas comerciales.
• Su dependencia de información incorporada compromete la interpretabilidad.

Para utilizar datos específicos en LLM, existen tres métodos predominantes:

• Incrustar datos dentro de las indicaciones del modelo, lo que le permite utilizar este contexto durante la generación de resultados. Puede ser de disparo cero (sin ejemplos), de pocos disparos (ejemplos limitados) o de muchos disparos (ejemplos abundantes). Este tipo de estímulo contextual orienta los modelos hacia resultados más matizados.
• Ajustar el modelo utilizando pares de indicaciones y completaciones.
• RAG, que recupera datos externos (no paramétricos) e integra estos datos en los avisos, enriqueciendo el contexto.

Sin embargo, el primer método se enfrenta a las limitaciones 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, aunque potente, requiere muchos recursos, especialmente con datos externos en constante evolución, lo que provoca retrasos en las implementaciones y mayores costos. RAG combinado con LLM ofrece una solución a las limitaciones mencionadas anteriormente.

Recuperación Generación Aumentada

RAG recupera datos externos (no paramétricos) e integra estos datos en indicaciones de ML, enriqueciendo el contexto. Lewis y cols. introdujo modelos RAG en 2020, conceptualizándolos como una fusión de un modelo secuencia a secuencia previamente entrenado (memoria paramétrica) y un índice vectorial denso de Wikipedia (memoria no paramétrica) al que se accede a través de un recuperador neuronal.

Así es como funciona RAG:

• Fuentes de datos – RAG puede extraer datos de diversas fuentes, incluidos repositorios de documentos, bases de datos o API.
• Formateo de datos – Tanto la consulta del usuario como los documentos se transforman a un formato adecuado para realizar comparaciones de relevancia.
• incrustaciones – Para facilitar esta comparación, la consulta y la colección de documentos (o biblioteca de conocimientos) se transforman en incrustaciones numéricas utilizando modelos de lenguaje. Estas incorporaciones encapsulan numéricamente 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 el 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 al mensaje original del usuario, mejorando así su contexto.
• Procesamiento de Maestría en Derecho – Con el contexto enriquecido, el mensaje se envía al LLM, que, debido a la inclusión de datos externos pertinentes, produce resultados relevantes y precisos.
• Actualizaciones asincrónicas – Para garantizar que los documentos de referencia permanezcan actualizados, se pueden actualizar de forma asincrónica junto con sus representaciones integradas. Esto garantiza que las respuestas futuras del modelo se basen en la información más reciente, lo que garantiza la precisión.

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

El siguiente diagrama muestra el flujo conceptual del uso de RAG con LLM.

Resumen de la solución

Se requieren los siguientes pasos para crear un chatbot contextual de respuesta a preguntas para una aplicación de servicios financieros:

1. Utilice el modelo de incrustación SageMaker JumpStart GPT-J-6B para generar incrustaciones para cada documento PDF en el Servicio de almacenamiento simple de Amazon (Amazon S3) directorio de carga.
2. Identifique los documentos relevantes siguiendo los siguientes pasos:
   • Generar una incrustación para la consulta del usuario usando el mismo modelo.
   • Utilice OpenSearch Serverless con la función de motor vectorial para buscar los K índices de documentos más relevantes en el espacio de incrustación.
   • Recuperar los documentos correspondientes utilizando los índices identificados.
3. Combine los documentos recuperados como contexto con el mensaje y la pregunta del usuario. Envíe esto a SageMaker LLM para generar respuestas.

Empleamos LangChain, un marco popular, para orquestar este proceso. LangChain está diseñado específicamente para reforzar aplicaciones impulsadas por LLM, ofreciendo una interfaz universal para varios LLM. Agiliza la integración de múltiples LLM, garantizando una persistencia perfecta del estado entre llamadas. Además, aumenta la eficiencia de los desarrolladores con funciones como plantillas de mensajes personalizables, agentes integrales de creación de aplicaciones e índices especializados para búsqueda y recuperación. Para una comprensión más profunda, consulte el Documentación de LangChain.

Requisitos previos

Necesita los siguientes requisitos previos para crear nuestro chatbot contextual:

Para obtener instrucciones sobre cómo configurar un motor vectorial OpenSearch Serverless, consulte Presentamos el motor vectorial para Amazon OpenSearch Serverless, ahora en versión preliminar.

Para obtener un tutorial completo de la siguiente solución, clone el Repositorio GitHub y consulte el Cuaderno Jupyter.

Implemente los modelos de ML usando SageMaker JumpStart

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

1. Implemente Llama 2 LLM de SageMaker JumpStart:

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

2. Implemente el modelo de incorporación 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
   

Fragmentar datos y crear un objeto de incrustación de documentos

En esta sección, divide los datos en documentos más pequeños. Chunking es una técnica para dividir textos grandes en partes más pequeñas. Es un paso esencial porque optimiza la relevancia de la consulta de 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 fragmento chunk_size=1600 porque es el tamaño aproximado de un párrafo. A medida que los modelos mejoren, el tamaño de su ventana de contexto aumentará, lo que permitirá tamaños de fragmentos más grandes.

Para obtener más detalles sobre cómo diseñar y realizar los esfuerzos de seguimiento y evaluación, refierase a Cuaderno Jupyter en el repositorio de GitHub para obtener la solución completa.

1. Extender LangChain SageMakerEndpointEmbeddings clase para crear una función de incrustaciones personalizada que utiliza el punto final de SageMaker gpt-j-6b-fp16 que creó anteriormente (como parte del empleo del modelo de incrustaciones):

   from langchain.embeddings import SagemakerEndpointEmbeddings
   from langchain.embeddings.sagemaker_endpoint import EmbeddingsContentHandler
   
   logger = logging.getLogger(__name__)
   
   # extend the SagemakerEndpointEmbeddings class from langchain to provide a custom embedding function
   class 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
   
   # class for serializing/deserializing requests/responses to/from the embeddings model
   class 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 embeddings
   
   def 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. Cree el objeto de incrustaciones y realice por lotes la creación de las incrustaciones de documentos:

   embeddings = create_sagemaker_embeddings_from_js_model(embeddings_endpoint_name, aws_region)

3. Estas incrustaciones se almacenan en el motor vectorial usando LangChain. OpenSearchVectorSearch. Almacena estas incrustaciones en la siguiente sección. Almacene el documento incrustado en OpenSearch Serverless. Ahora está listo para iterar sobre los documentos fragmentados, crear las incrustaciones y almacenarlas en el índice vectorial de OpenSearch Serverless creado en colecciones de búsqueda de vectores. Vea 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, ha dividido un documento grande en otros más pequeños, ha creado incrustaciones de vectores y los ha almacenado en un motor de vectores. Ahora puede responder preguntas sobre los datos de este documento. Como creó un índice sobre los datos, puede realizar una búsqueda semántica; De esta manera, solo los documentos más relevantes necesarios para responder la pregunta se pasan a través del mensaje al LLM. Esto le permite ahorrar tiempo y dinero al pasar únicamente los documentos relevantes al LLM. Para obtener más detalles sobre el uso de cadenas de documentos, consulte Documentos.

Complete los siguientes pasos para responder preguntas utilizando los documentos:

1. Para utilizar el punto final de SageMaker LLM con LangChain, utilice langchain.llms.sagemaker_endpoint.SagemakerEndpoint, que abstrae el punto final de SageMaker LLM. Realiza una transformación para la carga útil de solicitud y respuesta como se muestra en el siguiente código para la integración de LangChain SageMaker. Tenga en cuenta que es posible que deba ajustar el código en ContentHandler según el tipo de contenido y el formato de aceptación del modelo LLM que elija utilizar.

   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 content
   
   content_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á listo para interactuar con el documento financiero.

2. Utilice la siguiente plantilla de consultas y mensajes para hacer preguntas sobre el documento:

   from langchain import PromptTemplate, SagemakerEndpoint
   from langchain.llms.sagemaker_endpoint import LLMContentHandler
   
   query = "Summarize the earnings report and also what year is the report for"
   prompt_template = """Only use context to answer the question at the end.
    
   {context}
    
   Question: {question}
   Answer:"""
   
   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 content
   
   content_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)
   

Limpiar

Para evitar incurrir en costos futuros, elimine los puntos finales de inferencia de SageMaker que creó en este cuaderno. Puede hacerlo ejecutando lo siguiente en su cuaderno de SageMaker Studio:

# Delete LLM
llm_predictor.delete_model()
llm_predictor.delete_predictor(delete_endpoint_config=True)

# Delete Embeddings Model
embed_predictor.delete_model()
embed_predictor.delete_predictor(delete_endpoint_config=True)

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

Conclusión

En esta publicación, analizamos el uso de RAG como un enfoque para proporcionar un contexto de dominio específico a los LLM. Mostramos cómo utilizar SageMaker JumpStart para crear un chatbot contextual basado en RAG para una organización de servicios financieros utilizando Llama 2 y OpenSearch Serverless con un motor vectorial como almacén de datos vectoriales. Este método refina la generación de texto usando Llama 2 al obtener dinámicamente contexto relevante. ¡Estamos emocionados de verle traer sus datos personalizados e innovar con esta estrategia basada en RAG en SageMaker JumpStart!

Sobre los autores

Sunil Padmanabhan es Arquitecto de Soluciones para Startups en AWS. Como ex fundador de una startup y CTO, le apasiona el aprendizaje automático y se enfoca en ayudar a las nuevas empresas a aprovechar AI/ML para sus resultados comerciales y diseñar e implementar soluciones de ML/AI a escala.

suleman patel es Arquitecto de Soluciones Sénior en Amazon Web Services (AWS), con un enfoque especial en Aprendizaje Automático y Modernización. Aprovechando su experiencia tanto en negocios como en tecnología, Suleman ayuda a los clientes a diseñar y crear soluciones que abordan problemas comerciales del mundo real. Cuando no está inmerso en su trabajo, a Suleman le encanta explorar el aire libre, hacer viajes por carretera y cocinar platos deliciosos en la cocina.

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
• PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
• PlatoESG. Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
• PlatoSalud. Inteligencia en Biotecnología y Ensayos Clínicos. Accede Aquí.
• Fuente: https://aws.amazon.com/blogs/machine-learning/build-a-contextual-chatbot-for-financial-services-using-amazon-sagemaker-jumpstart-llama-2-and-amazon-opensearch-serverless-with-vector-engine/