Una introducción a BentoML Un marco de aplicación de IA unificado
Introducing BentoML A unified AI application framework.
Navegar desde la creación de modelos de aprendizaje automático (ML) hasta su implementación en producción a menudo puede ser un camino difícil. Es un proceso esencial pero complejo en el que los científicos de datos e ingenieros deben cerrar la brecha de conocimiento. Los científicos de datos, expertos en la creación de modelos, pueden tropezar cuando se trata de la implementación en producción. Por otro lado, los ingenieros pueden tener dificultades con la iteración continua de los modelos de ML, lo que lleva a operaciones ineficientes y propensas a errores.
Considera este escenario específico: acabas de crear un modelo de ML para resumir texto, que funciona de manera brillante en las pruebas. Planeas compartir este modelo con tu equipo para construir una aplicación sobre él. Sin embargo, enviar este modelo plantea un desafío único: asegurarte de que tu equipo pueda usar el modelo sin tener que modificar el código o configurar el entorno.
Entra BentoML.
BentoML es un marco de implementación de modelos de ML de código abierto diseñado para agilizar el proceso de implementación. Al facilitar una transición más fluida desde la creación del modelo hasta la producción, este marco de trabajo de extremo a extremo permite a los científicos de datos y desarrolladores centrarse en lo que mejor saben hacer, cerrando la brecha entre estos dos roles cruciales. Como resultado, los modelos pueden implementarse de manera rápida y escalable, asegurando un servicio de producción más estable.
Puedes usar el marco de trabajo BentoML para desarrollar puntos finales de implementación de modelos listos para producción. Aquí tienes el modus operandi de BentoML:
- Este boletín de inteligencia artificial es todo lo que necesitas #55
- Construyendo productos de IA con OpenAI Un curso gratuito de CoRise
- Fortaleciendo redes Desbloqueando el poder de ML, AI y DL para la d...
- Especificar un modelo: Antes de usar BentoML, debes comenzar con un modelo de ML o un conjunto de modelos. Estos modelos pueden entrenarse utilizando varias bibliotecas como TensorFlow o PyTorch.
- Guardar el modelo: Después de entrenar tu modelo, guárdalo en el Almacén Local de Modelos de BentoML. Sirve como un centro de gestión para todos tus modelos, brindando un acceso fácil para la implementación, así como una forma sistemática de realizar un seguimiento de ellos.
- Crear un Servicio BentoML: Crea un archivo
service.pypara envolver tu modelo y establecer la lógica de implementación. Especifica “Runners” (una abstracción en BentoML para optimizar la inferencia) para ejecutar inferencias de modelo a escala y construye los puntos finales que deseas exponer externamente. - Crear un Bento: Este paso implica empaquetar tu(s) modelo(s) y el Servicio BentoML en un Bento a través de un archivo de configuración YAML. Un Bento es un artefacto listo para implementar que agrupa todos los elementos necesarios: el código de tu modelo, sus dependencias y la lógica de implementación. Te daré un ejemplo más concreto más adelante.
- Implementar el Bento: Una vez que tu Bento esté preparado, es hora de implementarlo. Puedes contenerizar el Bento en una imagen Docker para implementarlo en Kubernetes. Si prefieres una solución todo en uno, puedes implementar tu Bento directamente en Yatai, una plataforma de código abierto en el ecosistema de BentoML que automatiza y gestiona implementaciones de aprendizaje automático en Kubernetes. Si deseas un servicio completamente administrado, considera implementar Bentos a través de BentoCloud, una solución sin servidor para construir y operar aplicaciones de IA.
Ahora que tienes una comprensión básica de BentoML y su flujo de trabajo, veamos un ejemplo de cómo BentoML simplifica la implementación y el servicio de modelos.
Configuración del entorno
Para ejecutar este proyecto localmente, asegúrate de tener lo siguiente:
- Python 3.8+
pipinstalado.
Después de eso, crea un directorio para almacenar todos los archivos del proyecto, incluido service.py como se mencionó anteriormente. Los crearé uno por uno.
mkdir bentoml-demo
cd bentoml-demoRecomiendo que uses un Entorno Virtual para el aislamiento de dependencias.
python -m venv venv
source venv/bin/activateCrea un archivo requirements.txt, que contiene todas las bibliotecas necesarias.
bentoml
transformers
torch>=2.0Instala las dependencias:
pip install -r requirements.txtDescargar modelos al Almacén Local de Modelos
En esta publicación de blog, uso un modelo Transformer de resumen de texto (sshleifer/distilbart-cnn-12-6) de Hugging Face Model Hub como ejemplo.
Como mencioné anteriormente, debes descargar el modelo al Almacén de Modelos de BentoML. Esto se hace a través de un script download_model.py, que utiliza la función bentoml.transformers.save_model(). Crea un archivo download_model.py como se muestra a continuación.
import transformers
import bentoml
modelo = "sshleifer/distilbart-cnn-12-6"
tarea = "resumen"
bentoml.transformers.save_model(
tarea,
transformers.pipeline(tarea, modelo=modelo),
metadata=dict(model_name=modelo),
)Ejecutar este script debería descargar y guardar tu modelo localmente.
python3 descargar_modelo.pySi la descarga es exitosa, el modelo debería aparecer en el repositorio de modelos. Puedes recuperar este modelo más tarde para crear un servicio BentoML.
$ bentoml modelos listar
Etiqueta Módulo Tamaño Hora de creación
resumen:5kiyqyq62w6pqnry bentoml.transformers 1.14 GiB 2023-07-10 11:57:40 Nota: Todos los modelos descargados en el repositorio de modelos se guardan en el directorio /home/user/bentoml/models/.
Crear un Servicio BentoML
Con un modelo listo para usar, puedes crear un Servicio BentoML definiendo un archivo service.py como se muestra a continuación. Este script crea una instancia de summarizer_runner a partir del modelo previamente descargado y lo envuelve dentro de un bentoml.Service(). La función summarize(), decorada con @svc.api(), especifica el punto de conexión de la API para el Servicio y la lógica para procesar las entradas y salidas.
import bentoml
summarizer_runner = bentoml.models.get("resumen:latest").to_runner()
svc = bentoml.Service(
name="resumen", runners=[summarizer_runner]
)
@svc.api(input=bentoml.io.Text(), output=bentoml.io.Text())
async def summarize(texto: str) -> str:
generado = await summarizer_runner.async_run(texto, max_length=3000)
return generado[0]["summary_text"]En el directorio del proyecto, utiliza bentoml serve para iniciar el servidor BentoML en modo de desarrollo.
$ bentoml serve service:svc --development --reload
2023-07-10T12:13:33+0800 [INFO] [cli] Las métricas de Prometheus para el servidor HTTP BentoServer de "service:svc" se pueden acceder en http://localhost:3000/metrics.
2023-07-10T12:13:34+0800 [INFO] [cli] Iniciando el servidor HTTP BentoServer de producción de "service:svc" escuchando en http://0.0.0.0:3000 (Presiona CTRL+C para salir)
2023-07-10 12:13:34 circus[5290] [INFO] Cargando el complemento...
2023-07-10 12:13:34 circus[5290] [INFO] Endpoint: 'tcp://127.0.0.1:61187'
2023-07-10 12:13:34 circus[5290] [INFO] Pub/sub: 'tcp://127.0.0.1:61188'
2023-07-10T12:13:34+0800 [INFO] [observer] Observando directorios: ['/Users/sherlock/Documents/bentoml-demo', '/Users/sherlock/bentoml/models']El servidor está ahora activo en http://0.0.0.0:3000, lo cual proporciona una interfaz de usuario web que puedes utilizar. Visita el sitio web, desplázate hacia abajo hasta Service APIs y haz clic en Probar.
Ingresa tu texto en el cuadro de Cuerpo de la solicitud y haz clic en Ejecutar. Observa el siguiente ejemplo sobre el concepto de Modelos de Lenguaje Grandes.
Entrada:
Un modelo de lenguaje grande (LLM, por sus siglas en inglés) es un modelo de lenguaje informatizado, encarnado por una red neuronal artificial que utiliza una enorme cantidad de "parámetros" (es decir, "neuronas" en sus capas con hasta decenas de millones a miles de millones de "pesos" entre ellas), que son (pre)entrenados en muchas GPUs en un tiempo relativamente corto debido al procesamiento paralelo masivo de vastas cantidades de textos no etiquetados que contienen hasta billones de tokens (es decir, partes de palabras) proporcionados por corpus como el Corpus de Wikipedia y Common Crawl, utilizando aprendizaje auto-supervisado o semi-supervisado, lo que resulta en un vocabulario tokenizado con una distribución de probabilidades. Los LLM pueden actualizarse utilizando GPUs adicionales para (pre)entrenar el modelo con incluso más parámetros en cantidades aún más vastas de textos no etiquetados.Salida del modelo de resumen de texto:
Un modelo de lenguaje grande (LLM) es un modelo de lenguaje computarizado, encarnado por una red neuronal artificial que utiliza una enorme cantidad de "parámetros" en sus capas con hasta decenas de millones a miles de millones de "pesos" entre ellos. Los LLM se pueden mejorar utilizando GPU adicionales para (pre)entrenar el modelo con incluso más parámetros en cantidades aún más vastas de textos no etiquetados.Construyendo un Bento
Ahora que el modelo está funcionando correctamente, necesitas empaquetarlo en el formato de distribución estándar en BentoML, también conocido como “Bento”. Un Bento contiene todo el código fuente, los archivos del modelo y las dependencias necesarias para ejecutar el servicio. Para construir un Bento, crea un archivo bentofile.yaml en el directorio del proyecto. Este archivo define las opciones de construcción, como las dependencias, la configuración de la imagen de Docker y los modelos. Aquí solo enumeraré la información básica requerida para construir un Bento, como el servicio, los archivos de Python que se incluirán y las dependencias. Consulta la documentación de BentoML para obtener más información.
service: 'service:svc'
include:
- '*.py'
python:
requirements_txt: requirements.txtEjecuta el comando bentoml build en el directorio del proyecto para construir el Bento. Puedes encontrar todos los Bentos creados en /home/user/bentoml/bentos/.
$ bentoml build
Construyendo el servicio BentoML "summarization:ulnyfbq66gagsnry" desde el contexto de construcción "/Users/sherlock/Documents/bentoml-demo".
Empaquetando el modelo "summarization:5kiyqyq62w6pqnry"
██████╗░███████╗███╗░░██╗████████╗░█████╗░███╗░░░███╗██╗░░░░░
██╔══██╗██╔════╝████╗░██║╚══██╔══╝██╔══██╗████╗░████║██║░░░░░
██████╦╝█████╗░░██╔██╗██║░░░██║░░░██║░░██║██╔████╔██║██║░░░░░
██╔══██╗██╔══╝░░██║╚████║░░░██║░░░██║░░██║██║╚██╔╝██║██║░░░░░
██████╦╝███████╗██║░╚███║░░░██║░░░╚█████╔╝██║░╚═╝░██║███████╗
╚═════╝░╚══════╝╚═╝░░╚══╝░░░╚═╝░░░░╚════╝░╚═╝░░░░░╚═╝╚══════╝
Bento construido con éxito (etiqueta="summarization:ulnyfbq66gagsnry").
Posibles pasos siguientes:
* Conteneriza tu Bento con `bentoml containerize`:
$ bentoml containerize summarization:ulnyfbq66gagsnry
* Envía a BentoCloud con `bentoml push`:
$ bentoml push summarization:ulnyfbq66gagsnryPara ver todos los Bentos disponibles, ejecuta lo siguiente:
$ bentoml list
Etiqueta Tamaño Hora de creación
summarization:ulnyfbq66gagsnry 1.25 GiB 2023-07-10 15:28:51Desplegar el Bento
Una vez que el Bento esté listo, puedes usar bentoml serve para servirlo en producción. Ten en cuenta que si tienes varias versiones del mismo modelo, puedes cambiar la etiqueta latest por la versión correspondiente.
$ bentoml serve summarization:latest
2023-07-10T15:36:58+0800 [INFO] [cli] Entorno para el trabajador 0: establecer el recuento de hilos de la CPU en 12
2023-07-10T15:36:58+0800 [INFO] [cli] Las métricas de Prometheus para el servidor HTTP BentoServer desde "summarization:latest" se pueden acceder en http://localhost:3000/metrics.
2023-07-10T15:36:59+0800 [INFO] [cli] Iniciando el servidor HTTP BentoServer en producción desde "summarization:latest" escuchando en http://0.0.0.0:3000 (Presiona CTRL+C para salir)Alternativamente, puedes contenerizar el Bento con Docker. Al crear el Bento, se creó automáticamente un Dockerfile en /home/user/bentoml/bentos/summarization/ulnyfbq66gagsnry/env/docker/. Para crear una imagen de Docker, simplemente ejecuta lo siguiente:
bentoml containerize summarization:latestVer la imagen de Docker creada:
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
summarization ulnyfbq66gagsnry da287141ef3e Hace 7 segundos 2.43GBPuedes ejecutar la imagen de Docker localmente:
docker run -it --rm -p 3000:3000 summarization:ulnyfbq66gagsnry serveCon la imagen de Docker, puedes ejecutar el modelo en Kubernetes y crear un Servicio de Kubernetes para exponerlo, de manera que tus usuarios puedan interactuar con él.
Si estás buscando una solución integral para implementar modelos, puedes elegir Yatai para implementar Bentos y gestionar la implementación a gran escala en Kubernetes. Yatai es un componente importante en el ecosistema de BentoML y merece su propia publicación en el blog para explicar los detalles. Si estás interesado, echa un vistazo al repositorio de GitHub de Yatai.
Conclusión
Llevar tus modelos de aprendizaje automático desde el entrenamiento hasta la producción no es una tarea fácil, y aquí es donde BentoML realmente destaca. Con BentoML, puedes centrarte en la construcción del modelo mientras el framework se encarga de los detalles de implementación.
A medida que los modelos de ML se vuelven cada vez más integrales a las operaciones comerciales, contar con una solución de implementación y servicio de modelos optimizada como BentoML se vuelve indispensable. No solo BentoML facilita la implementación de modelos, sino que también garantiza que tus modelos se gestionen de manera eficiente y puedan escalar según tus necesidades. Si estás interesado, comienza hoy mismo con BentoML y experimenta la facilidad de la implementación de modelos. ¡Feliz codificación!
