Cree aplicaciones de chatbot personalizadas con modelos de OpenChatkit en Amazon SageMaker | Servicios web de Amazon

Los modelos de lenguaje grande (LLM) de código abierto se han vuelto populares, lo que permite a los investigadores, desarrolladores y organizaciones acceder a estos modelos para fomentar la innovación y la experimentación. Esto fomenta la colaboración de la comunidad de código abierto para contribuir al desarrollo y la mejora de los LLM. Los LLM de código abierto brindan transparencia a la arquitectura del modelo, el proceso de capacitación y los datos de capacitación, lo que permite a los investigadores comprender cómo funciona el modelo e identificar posibles sesgos y abordar las preocupaciones éticas. Estos LLM de código abierto están democratizando la IA generativa al hacer que la tecnología avanzada de procesamiento de lenguaje natural (NLP) esté disponible para una amplia gama de usuarios para crear aplicaciones comerciales de misión crítica. GPT-NeoX, LLaMA, Alpaca, GPT4All, Vicuna, Dolly y OpenAssistant son algunos de los LLM populares de código abierto.

OpenChatKit es un LLM de código abierto que se utiliza para crear aplicaciones de chatbot especializadas y de propósito general, lanzado por Together Computer en marzo de 2023 bajo la licencia Apache-2.0. Este modelo permite a los desarrolladores tener más control sobre el comportamiento del chatbot y adaptarlo a sus aplicaciones específicas. OpenChatKit proporciona un conjunto de herramientas, un bot base y bloques de construcción para crear chatbots potentes y completamente personalizados. Los componentes clave son los siguientes:

• Un LLM ajustado por instrucciones, ajustado para chatear desde GPT-NeoX-20B de EleutherAI con más de 43 millones de instrucciones en cómputo 100% negativo de carbono. El GPT-NeoXT-Chat-Base-20B El modelo se basa en el modelo GPT-NeoX de EleutherAI y está ajustado con datos centrados en interacciones de estilo de diálogo.
• Recetas de personalización para afinar el modelo y lograr una alta precisión en sus tareas.
• Un sistema de recuperación extensible que le permite aumentar las respuestas de los bots con información de un repositorio de documentos, API u otra fuente de información de actualización en vivo en el momento de la inferencia.
• Un modelo de moderación, ajustado a partir de GPT-JT-6B, diseñado para filtrar a qué preguntas responde el bot.

La escala y el tamaño cada vez mayores de los modelos de aprendizaje profundo presentan obstáculos para implementar con éxito estos modelos en aplicaciones de IA generativa. Para satisfacer las demandas de baja latencia y alto rendimiento, se vuelve esencial emplear métodos sofisticados como el paralelismo de modelos y la cuantificación. Al carecer de competencia en la aplicación de estos métodos, numerosos usuarios encuentran dificultades para iniciar el alojamiento de modelos considerables para casos de uso de IA generativa.

En esta publicación, mostramos cómo implementar modelos de OpenChatKit (GPT-NeoXT-Chat-Base-20B and GPT-JT-Moderation-6B) modelos en Amazon SageMaker utilizando DJL Serving y bibliotecas paralelas de modelos de código abierto como DeepSpeed ​​y Hugging Face Accelerate. Utilizamos DJL Serving, que es una solución de servicio modelo universal de alto rendimiento impulsada por Deep Java Library (DJL) que es independiente del lenguaje de programación. Demostramos cómo la biblioteca Hugging Face Accelerate simplifica la implementación de modelos grandes en múltiples GPU, lo que reduce la carga de ejecutar LLM de forma distribuida. ¡Empecemos!

Sistema de recuperación extensible

Un sistema de recuperación extensible es uno de los componentes clave de OpenChatKit. Le permite personalizar la respuesta del bot en función de una base de conocimientos de dominio cerrado. Si bien los LLM pueden retener el conocimiento fáctico en los parámetros de su modelo y pueden lograr un rendimiento notable en las tareas de NLP posteriores cuando se ajustan con precisión, su capacidad para acceder y predecir con precisión el conocimiento de dominio cerrado sigue estando restringida. Por lo tanto, cuando se les presentan tareas intensivas en conocimiento, su rendimiento se ve afectado por el de las arquitecturas específicas de tareas. Puede usar el sistema de recuperación de OpenChatKit para aumentar el conocimiento en sus respuestas de fuentes de conocimiento externas como Wikipedia, repositorios de documentos, API y otras fuentes de información.

El sistema de recuperación permite que el chatbot acceda a la información actual al obtener detalles pertinentes en respuesta a una consulta específica, proporcionando así el contexto necesario para que el modelo genere respuestas. Para ilustrar la funcionalidad de este sistema de recuperación, brindamos soporte para un índice de artículos de Wikipedia y ofrecemos un código de ejemplo que demuestra cómo invocar una API de búsqueda web para la recuperación de información. Siguiendo la documentación proporcionada, puede integrar el sistema de recuperación con cualquier conjunto de datos o API durante el proceso de inferencia, lo que permite que el chatbot incorpore datos actualizados dinámicamente en sus respuestas.

modelo de moderación

Los modelos de moderación son importantes en las aplicaciones de chatbot para hacer cumplir el filtrado de contenido, el control de calidad, la seguridad del usuario y las razones legales y de cumplimiento. La moderación es una tarea difícil y subjetiva, y depende mucho del dominio de la aplicación del chatbot. OpenChatKit proporciona herramientas para moderar la aplicación de chatbot y monitorear las indicaciones de texto de entrada para detectar cualquier contenido inapropiado. El modelo de moderación proporciona una buena línea de base que se puede adaptar y personalizar para diversas necesidades.

OpenChatKit tiene un modelo de moderación de 6 mil millones de parámetros, GPT-JT-Moderation-6B, que puede moderar el chatbot para limitar las entradas a los temas moderados. Aunque el modelo en sí tiene algo de moderación incorporada, TogetherComputer entrenó a un GPT-JT-Moderación-6B modelo con Ontocord.ai's Conjunto de datos de moderación de la OIG. Este modelo se ejecuta junto con el chatbot principal para verificar que tanto la entrada del usuario como la respuesta del bot no contengan resultados inapropiados. También puede usar esto para detectar cualquier pregunta fuera del dominio para el chatbot y anular cuando la pregunta no sea parte del dominio del chatbot.

El siguiente diagrama ilustra el flujo de trabajo de OpenChatKit.

Casos de uso del sistema de recuperación extensible

Aunque podemos aplicar esta técnica en varias industrias para crear aplicaciones de IA generativa, en esta publicación analizamos casos de uso en la industria financiera. La generación aumentada de recuperación se puede emplear en la investigación financiera para generar automáticamente informes de investigación sobre empresas, industrias o productos financieros específicos. Al recuperar información relevante de bases de conocimiento internas, archivos financieros, artículos de noticias y trabajos de investigación, puede generar informes completos que resumen información clave, métricas financieras, tendencias de mercado y recomendaciones de inversión. Puede usar esta solución para monitorear y analizar noticias financieras, sentimiento del mercado y tendencias.

Resumen de la solución

Los siguientes pasos están involucrados para construir un chatbot usando modelos de OpenChatKit e implementarlos en SageMaker:

1. Descarga la base de chat GPT-NeoXT-Chat-Base-20B modelar y empaquetar los artefactos del modelo que se cargarán en Servicio de almacenamiento simple de Amazon (Amazon S3).
2. Utilice un contenedor de inferencia de modelo grande (LMI) de SageMaker, configure las propiedades y configure el código de inferencia personalizado para implementar este modelo.
3. Configure técnicas paralelas de modelos y utilice bibliotecas de optimización de inferencias en las propiedades de servicio de DJL. Usaremos Hugging Face Accelerate como motor para servir DJL. Además, definimos configuraciones paralelas de tensor para dividir el modelo.
4. Cree un modelo de SageMaker y una configuración de punto final e implemente el punto final de SageMaker.

Puede seguir ejecutando el cuaderno en el Repositorio GitHub.

Descarga el modelo de OpenChatKit

Primero, descargamos el modelo base de OpenChatKit. Usamos huggingface_hub y use instantánea_descargar para descargar el modelo, que descarga un repositorio completo en una revisión determinada. Las descargas se realizan simultáneamente para acelerar el proceso. Ver el siguiente código:

from huggingface_hub import snapshot_download
from pathlib import Path
import os
# - This will download the model into the current directory where ever the jupyter notebook is running
local_model_path = Path("./openchatkit")
local_model_path.mkdir(exist_ok=True)
model_name = "togethercomputer/GPT-NeoXT-Chat-Base-20B"
# Only download pytorch checkpoint files
allow_patterns = ["*.json", "*.pt", "*.bin", "*.txt", "*.model"]
# - Leverage the snapshot library to donload the model since the model is stored in repository using LFS
chat_model_download_path = snapshot_download( repo_id=model_name,#A user or an organization name and a repo name cache_dir=local_model_path, #Path to the folder where cached files are stored. allow_patterns=allow_patterns, #only files matching at least one pattern are downloaded.
)

Propiedades de servicio DJL

Puede utilizar contenedores LMI de SageMaker para alojar grandes modelos generativos de IA con código de inferencia personalizado sin proporcionar su propio código de inferencia. Esto es extremadamente útil cuando no hay un procesamiento previo personalizado de los datos de entrada o un procesamiento posterior de las predicciones del modelo. También puede implementar un modelo utilizando un código de inferencia personalizado. En esta publicación, demostramos cómo implementar modelos de OpenChatKit con código de inferencia personalizado.

SageMaker espera los artefactos del modelo en formato tar. Creamos cada modelo de OpenChatKit con los siguientes archivos: serving.properties y model.py.

La serving.properties El archivo de configuración indica a DJL Serving qué bibliotecas de paralelización de modelos y optimización de inferencias le gustaría usar. La siguiente es una lista de las configuraciones que usamos en este archivo de configuración:

openchatkit/serving.properties
engine = Python
option.tensor_parallel_degree = 4
option.s3url = {{s3url}}

Este contiene los siguientes parámetros:

• motor – El motor para que DJL lo use.
• opción.punto de entrada – El archivo o módulo Python del punto de entrada. Esto debe alinearse con el motor que se está utilizando.
• opción.s3url – Establezca esto en el URI del depósito S3 que contiene el modelo.
• opción.modelid – Si desea descargar el modelo de huggingface.co, puede configurar option.modelid al ID de modelo de un modelo preentrenado alojado dentro de un repositorio de modelos en huggingface.co (https://huggingface.co/models). El contenedor usa este ID de modelo para descargar el repositorio de modelos correspondiente en huggingface.co.
• opción.tensor_parallel_degree – Establezca esto en la cantidad de dispositivos de GPU en los que DeepSpeed ​​necesita particionar el modelo. Este parámetro también controla la cantidad de trabajadores por modelo que se iniciarán cuando se ejecute DJL Serving. Por ejemplo, si tenemos una máquina de 8 GPU y estamos creando ocho particiones, tendremos un trabajador por modelo para atender las solicitudes. Es necesario ajustar el grado de paralelismo e identificar el valor óptimo para un modelo de arquitectura y plataforma de hardware determinados. A esta habilidad la llamamos paralelismo adaptado a la inferencia.

Consulte Configuraciones y ajustes para obtener una lista exhaustiva de opciones.

Modelos de OpenChatKit

La implementación del modelo base de OpenChatKit tiene los siguientes cuatro archivos:

• modelo.py – Este archivo implementa la lógica de manejo para el modelo principal de OpenChatKit GPT-NeoX. Recibe la solicitud de entrada de inferencia, carga el modelo, carga el índice de Wikipedia y entrega la respuesta. Referirse a model.py(parte creada del cuaderno) para obtener detalles adicionales. model.py utiliza las siguientes clases clave:
  • Servicio OpenChatKit – Esto maneja el paso de datos entre el modelo GPT-NeoX, la búsqueda de Faiss y el objeto de conversación. WikipediaIndex y Conversation los objetos se inicializan y las conversaciones de chat de entrada se envían al índice para buscar contenido relevante de Wikipedia. Esto también genera una ID única para cada invocación si no se proporciona una con el fin de almacenar las indicaciones en Amazon DynamoDB.
  • modelo de chat – Esta clase carga el modelo y el tokenizador y genera la respuesta. Maneja la partición del modelo en múltiples GPU usando tensor_parallel_degreey configura el dtypes y device_map. Las indicaciones se pasan al modelo para generar respuestas. Un criterio de parada StopWordsCriteria está configurado para que la generación solo produzca la respuesta del bot en la inferencia.
  • ModeraciónModelo – Usamos dos modelos de moderación en el ModerationModel clase: el modelo de entrada para indicar al modelo de chat que la entrada es inapropiada para anular el resultado de la inferencia y el modelo de salida para anular el resultado de la inferencia. Clasificamos la solicitud de entrada y la respuesta de salida con las siguientes etiquetas posibles:
    • casual
    • necesita precaución
    • necesita intervención (esto está marcado para ser moderado por el modelo)
    • posiblemente necesita precaución
    • probablemente necesita precaución
• wikipedia_prepare.py – Este archivo maneja la descarga y preparación del índice de Wikipedia. En esta publicación, usamos un índice de Wikipedia proporcionado en los conjuntos de datos de Hugging Face. Para buscar en los documentos de Wikipedia texto relevante, el índice debe descargarse de Hugging Face porque no está empaquetado en ningún otro lugar. El wikipedia_prepare.py El archivo es responsable de manejar la descarga cuando se importa. Solo un único proceso de los múltiples que se ejecutan para la inferencia puede clonar el repositorio. El resto espera hasta que los archivos estén presentes en el sistema de archivos local.
• wikipedia.py – Este archivo se utiliza para buscar en el índice de Wikipedia documentos contextualmente relevantes. La consulta de entrada se tokeniza y las incrustaciones se crean usando mean_pooling. Calculamos métricas de distancia de similitud de coseno entre la consulta incrustada y el índice de Wikipedia para recuperar oraciones de Wikipedia contextualmente relevantes. Referirse a wikipedia.py para obtener detalles de implementación.

#function to create sentence embedding using mean_pooling
def mean_pooling(token_embeddings, mask): token_embeddings = token_embeddings.masked_fill(~mask[..., None].bool(), 0.0) sentence_embeddings = token_embeddings.sum(dim=1) / mask.sum(dim=1)[..., None] return sentence_embeddings #function to compute cosine similarity distance between 2 embeddings def cos_sim_2d(x, y): norm_x = x / np.linalg.norm(x, axis=1, keepdims=True) norm_y = y / np.linalg.norm(y, axis=1, keepdims=True) return np.matmul(norm_x, norm_y.T)

• conversación.py – Este archivo se usa para almacenar y recuperar el hilo de conversación en DynamoDB para pasarlo al modelo y al usuario. conversation.py está adaptado del repositorio OpenChatKit de código abierto. Este archivo se encarga de definir el objeto que almacena los turnos de conversación entre el humano y el modelo. Con esto, el modelo puede retener una sesión para la conversación, lo que permite al usuario consultar mensajes anteriores. Debido a que las invocaciones de puntos finales de SageMaker no tienen estado, esta conversación debe almacenarse en una ubicación externa a las instancias de los puntos finales. Al iniciarse, la instancia crea una tabla de DynamoDB si no existe. Todas las actualizaciones de la conversación se almacenan en DynamoDB en función de la session_id clave, que es generada por el punto final. Cualquier invocación con un ID de sesión recuperará la cadena de conversación asociada y la actualizará según sea necesario.

Cree un contenedor de inferencia LMI con dependencias personalizadas

La búsqueda de índice utiliza Facebook Faiss biblioteca para realizar la búsqueda de similitud. Debido a que esto no está incluido en la imagen base de LMI, el contenedor debe adaptarse para instalar esta biblioteca. El siguiente código define un Dockerfile que instala Faiss desde el origen junto con otras bibliotecas que necesita el extremo del bot. usamos el sm-docker utilidad para construir y enviar la imagen a Registro de contenedores elásticos de Amazon (Amazon ECR) de Estudio Amazon SageMaker. Referirse a Uso de la CLI de compilación de imágenes de Amazon SageMaker Studio para crear imágenes de contenedor desde sus cuadernos de Studio para más información.

El contenedor DJL no tiene Conda instalado, por lo que Faiss debe clonarse y compilarse desde la fuente. Para instalar Faiss, se deben instalar las dependencias para usar las API de BLAS y el soporte de Python. Después de instalar estos paquetes, Faiss se configura para usar AVX2 y CUDA antes de compilarse con las extensiones de Python instaladas.

pandas, fastparquet, boto3y git-lfs se instalan después porque son necesarios para descargar y leer los archivos de índice.

FROM 763104351884.dkr.ecr.us-east-1.amazonaws.com/djl-inference:0.21.0-deepspeed0.8.0-cu117
ARG FAISS_URL=https://github.com/facebookresearch/faiss.git
RUN apt-get update && apt-get install -y git-lfs wget cmake pkg-config build-essential apt-utils
RUN apt search openblas && apt-get install -y libopenblas-dev swig
RUN git clone $FAISS_URL && cd faiss && cmake -B build . -DFAISS_OPT_LEVEL=avx2 -DCMAKE_CUDA_ARCHITECTURES="86" && make -C build -j faiss && make -C build -j swigfaiss && make -C build -j swigfaiss_avx2 && (cd build/faiss/python && python -m pip install ) RUN pip install pandas fastparquet boto3 && git lfs install --skip-repo && apt-get clean all

Crea el modelo

Ahora que tenemos la imagen de Docker en Amazon ECR, podemos continuar con la creación del objeto de modelo de SageMaker para los modelos de OpenChatKit. desplegamos GPT-NeoXT-Chat-Base-20B modelos de moderación de entrada y salida utilizando GPT-JT-Moderation-6B. Referirse a crear_modelo para más información.

from sagemaker.utils import name_from_base chat_model_name = name_from_base(f"gpt-neoxt-chatbase-ds")
print(chat_model_name) create_model_response = sm_client.create_model( ModelName=chat_model_name, ExecutionRoleArn=role, PrimaryContainer={ "Image": chat_inference_image_uri, "ModelDataUrl": s3_code_artifact, },
)
chat_model_arn = create_model_response["ModelArn"] print(f"Created Model: {chat_model_arn}")

Configurar el punto final

A continuación, definimos las configuraciones de punto final para los modelos de OpenChatKit. Implementamos los modelos usando el tipo de instancia ml.g5.12xlarge. Referirse a crear_endpoint_config para más información.

chat_endpoint_config_name = f"{chat_model_name}-config"
chat_endpoint_name = f"{chat_model_name}-endpoint" chat_endpoint_config_response = sm_client.create_endpoint_config( EndpointConfigName=chat_endpoint_config_name, ProductionVariants=[ { "VariantName": "variant1", "ModelName": chat_model_name, "InstanceType": "ml.g5.12xlarge", "InitialInstanceCount": 1, "ContainerStartupHealthCheckTimeoutInSeconds": 3600, }, ],
)

Implementar el punto final

Finalmente, creamos un punto final usando el modelo y la configuración del punto final que definimos en los pasos anteriores:

chat_create_endpoint_response = sm_client.create_endpoint(
EndpointName=f"{chat_endpoint_name}", EndpointConfigName=chat_endpoint_config_name
)
print(f"Created Endpoint: {chat_create_endpoint_response['EndpointArn']},")

Ejecutar inferencia desde modelos de OpenChatKit

Ahora es el momento de enviar solicitudes de inferencia al modelo y obtener las respuestas. Pasamos el indicador de texto de entrada y los parámetros del modelo, como temperature, top_ky max_new_tokens. La calidad de las respuestas del chatbot se basa en los parámetros especificados, por lo que se recomienda comparar el rendimiento del modelo con estos parámetros para encontrar la configuración óptima para su caso de uso. La solicitud de entrada se envía primero al modelo de moderación de entrada y la salida se envía a ChatModel para generar las respuestas. Durante este paso, el modelo usa el índice de Wikipedia para recuperar secciones contextualmente relevantes para el modelo como indicador para obtener respuestas específicas del dominio del modelo. Finalmente, la respuesta del modelo se envía al modelo de moderación de salida para verificar la clasificación y luego se devuelven las respuestas. Ver el siguiente código:

def chat(prompt, session_id=None, **kwargs): if session_id: chat_response_model = smr_client.invoke_endpoint( EndpointName=chat_endpoint_name, Body=json.dumps( { "inputs": prompt, "parameters": { "temperature": 0.6, "top_k": 40, "max_new_tokens": 512, "session_id": session_id, "no_retrieval": True, }, } ), ContentType="application/json", ) else: chat_response_model = smr_client.invoke_endpoint( EndpointName=chat_endpoint_name, Body=json.dumps( { "inputs": prompt, "parameters": { "temperature": 0.6, "top_k": 40, "max_new_tokens": 512, }, } ), ContentType="application/json", ) response = chat_response_model["Body"].read().decode("utf8") return response
prompts = "What does a data engineer do?"
chat(prompts)

Consulte las interacciones de chat de muestra a continuación.

Limpiar

Siga las instrucciones en la sección de limpieza de para eliminar los recursos aprovisionados como parte de esta publicación para evitar cargos innecesarios. Referirse a Precios de Amazon SageMaker para obtener detalles sobre el costo de las instancias de inferencia.

Conclusión

En esta publicación, discutimos la importancia de los LLM de código abierto y cómo implementar un modelo OpenChatKit en SageMaker para crear aplicaciones de chatbot de próxima generación. Discutimos varios componentes de los modelos de OpenChatKit, modelos de moderación y cómo usar una fuente de conocimiento externa como Wikipedia para flujos de trabajo de recuperación de generación aumentada (RAG). Puede encontrar instrucciones paso a paso en el Cuaderno de GitHub. Háganos saber acerca de las increíbles aplicaciones de chatbot que está creando. ¡Salud!

Acerca de los autores

Patel Dhawal es Arquitecto Principal de Aprendizaje Automático en AWS. Ha trabajado con organizaciones que van desde grandes empresas hasta empresas emergentes medianas en problemas relacionados con la computación distribuida y la inteligencia artificial. Se enfoca en el aprendizaje profundo, incluidos los dominios de NLP y Computer Vision. Ayuda a los clientes a lograr una inferencia de modelos de alto rendimiento en SageMaker.

Vikram Elango es Arquitecto Sr. Especialista en Soluciones AIML en AWS, con sede en Virginia, EE. UU. Actualmente se centra en IA generativa, LLM, ingeniería rápida, optimización de inferencia de modelos grandes y escalado de ML en todas las empresas. Vikram ayuda a los clientes de la industria financiera y de seguros con diseño y liderazgo intelectual para crear e implementar aplicaciones de aprendizaje automático a escala. En su tiempo libre, disfruta viajar, hacer caminatas, cocinar y acampar con su familia.

Andrew Smith es ingeniero de soporte en la nube en el equipo de SageMaker, Vision & Other en AWS, con sede en Sídney, Australia. Apoya a los clientes que utilizan muchos servicios de IA/ML en AWS con experiencia en el trabajo con Amazon SageMaker. Fuera del trabajo, disfruta pasar tiempo con amigos y familiares, así como aprender sobre diferentes tecnologías.

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• EVM Finanzas. Interfaz unificada para finanzas descentralizadas. Accede Aquí.
• Grupo de medios cuánticos. IR/PR amplificado. Accede Aquí.
• PlatoAiStream. Inteligencia de datos Web3. Conocimiento amplificado. Accede Aquí.
• Fuente: https://aws.amazon.com/blogs/machine-learning/build-custom-chatbot-applications-using-openchatkit-models-on-amazon-sagemaker/