Envíe el modelo de código abierto Falcon-7B a la nube basado en Truss+Docker+Kubernetes (traducción)

fondo

Hasta ahora, hemos visto las capacidades de ChatGPT y las excelentes funciones que tiene para ofrecer. Sin embargo, para las aplicaciones empresariales, un modelo de código cerrado como ChatGPT puede presentar riesgos, ya que las propias empresas no tienen control sobre sus datos. Aunque OpenAI afirma que los datos de los usuarios no se almacenarán ni utilizarán para entrenar modelos, esto no garantiza que los datos no se filtren de alguna manera.

Para abordar algunos de los problemas asociados con los modelos de código cerrado, los investigadores se apresuran a crear modelos de lenguaje extenso (LLM) de código abierto que compitan con modelos como ChatGPT. Con modelos de código abierto, las empresas pueden alojar modelos en un entorno de nube seguro, lo que reduce el riesgo de filtraciones de datos. Lo que es más importante, obtiene total transparencia en el funcionamiento interno del modelo, lo que ayuda a los usuarios a construir relaciones más confiables con los sistemas de IA.

Con los avances recientes en LLM de código abierto, es tentador probar nuevos modelos y ver cómo se comparan con modelos de código cerrado como ChatGPT.

Sin embargo, existen enormes barreras para ejecutar un modelo de código abierto en la actualidad. Por ejemplo, es mucho más fácil llamar a la API de ChatGPT que entender cómo ejecutar un LLM de código abierto.

En esta publicación, mi objetivo es superar las dificultades antes mencionadas al mostrar cómo un modelo de código abierto como el modelo Falcon-7B se puede ejecutar en la nube en un entorno similar al de producción. Eventualmente, podremos acceder a estos modelos a través de puntos finales de API similares a ChatGPT.

desafío

Un desafío importante en la ejecución de modelos de código abierto es la falta de recursos informáticos. Incluso un modelo "pequeño" como el Falcon-7B requiere una GPU para funcionar.

Para resolver este problema, podemos utilizar GPU en la nube. Sin embargo, esto presenta otro desafío. ¿Cómo contenedorizamos LLM? ¿Cómo habilitamos la compatibilidad con GPU? Habilitar la compatibilidad con GPU puede ser complicado, ya que requiere conocimientos de CUDA. Usar CUDA puede ser una molestia porque debe descubrir cómo instalar las dependencias correctas de CUDA y qué versiones son compatibles.

[Nota del traductor] CUDA (Arquitectura de dispositivo unificado de cómputo) es una plataforma informática lanzada por el fabricante de tarjetas gráficas NVIDIA. CUDA™ es una arquitectura de cómputo paralelo de uso general lanzada por NVIDIA, que incluye la arquitectura del conjunto de instrucciones (ISA) de CUDA y el motor de cómputo paralelo dentro de la GPU. Los desarrolladores pueden usar C, C++ y FORTRAN para escribir programas para la arquitectura CUDA™.

Por lo tanto, para evitar la trampa mortal de CUDA, muchas empresas han creado soluciones que pueden contener fácilmente modelos mientras admiten GPU. En esta publicación de blog, usaremos una herramienta de código abierto llamada Truss para ayudarnos a contener fácilmente LLM sin demasiados problemas.

Truss permite a los desarrolladores contener fácilmente modelos creados con cualquier marco.

¿Por qué usar Truss?

Armadura — https://truss.baseten.co/e2e。

Truss tiene muchas funciones útiles listas para usar, como:

• Convierta modelos de Python en microservicios con puntos finales de API listos para producción
• Congelar dependencias a través de Docker
• Compatibilidad con la inferencia de GPU
• Preprocesamiento simple y posprocesamiento del modelo.
• Gestión de secretos fácil y segura

He usado Truss antes para implementar modelos de aprendizaje automático y el proceso fue fluido y fácil. Truss crea automáticamente archivos dockerfiles y administra las dependencias de Python. Todo lo que tenemos que hacer es proporcionar código para nuestro modelo.

En realidad, la razón principal por la que queremos usar una herramienta como Truss es que facilita la implementación de nuestros modelos con soporte para GPU.

plan

Estos son los principales que cubriré en esta publicación de blog:

1. Configurar el Falcon 7B localmente con Truss
2. Si tiene una GPU (tengo una RTX 3080), ejecute el modelo localmente
3. Contenga el modelo y ejecútelo con Docker
4. Cree un clúster de Kubernetes habilitado para GPU en Google Cloud para ejecutar nuestro modelo

Sin embargo, no se preocupe, si el paso 2 no tiene una GPU, aún puede ejecutar el modelo en la nube.

La siguiente es la dirección del almacén de código de Github, que contiene todo el código relevante que se describe más adelante en este artículo (si desea continuar leyendo):

https://github.com/htrivedi99/falcon-7b-truss

¡Empecemos!

Paso 1: Configuración local de Falcon 7B usando Truss

Primero, necesitamos crear un proyecto con la versión de Python ≥ 3.8.

Luego, descargaremos el modelo del sitio web oficial de HuggingFace y usaremos Truss para empaquetar. Aquí están las dependencias que necesitamos instalar:

pip install truss

Luego, cree un script llamado main.py en su proyecto de Python. Este es un script temporal que usaremos para procesar Truss.

A continuación, configuraremos el paquete Truss ejecutando el siguiente comando en la terminal:

truss init falcon_7b_truss

Presione 'y' si se le solicita que cree un nuevo Truss. Una vez completado, debería ver un nuevo directorio llamado falcon_7b_truss. En ese directorio, habrá algunos archivos y carpetas generados automáticamente. Necesitamos completar los siguientes elementos: model.py, que se encuentra en la carpeta del modelo y también se hace referencia en el archivo config.yaml.

Como mencioné antes, Truss solo necesita el código para nuestro modelo, se encarga de todo lo demás automáticamente. Escribiremos el código en model.py, pero debe estar escrito en un formato específico.

Truss espera que cada modelo admita al menos tres funciones: __init__, cargar y predecir.

• __init__ se usa principalmente para crear variables de clase
• load es donde descargamos el modelo del sitio web oficial de HuggingFace
• predecir es donde llamamos al modelo Aquí está el código completo de model.py:

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
from typing import Dict
 
MODEL_NAME = "tiiuae/falcon-7b-instruct"
DEFAULT_MAX_LENGTH = 128
 
 
class Model:
 def __init__(self, data_dir: str, config: Dict, **kwargs) -> None:
 self._data_dir = data_dir
 self._config = config
 self.device = "cuda" if torch.cuda.is_available() else "cpu"
 print("THE DEVICE INFERENCE IS RUNNING ON IS: ", self.device)
 self.tokenizer = None
 self.pipeline = None
 
 def load(self):
 self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
 model_8bit = AutoModelForCausalLM.from_pretrained(
 MODEL_NAME,
 device_map="auto",
 load_in_8bit=True,
 trust_remote_code=True)
 
 self.pipeline = pipeline(
 "text-generation",
 model=model_8bit,
 tokenizer=self.tokenizer,
 torch_dtype=torch.bfloat16,
 trust_remote_code=True,
 device_map="auto",
 )
 
 def predict(self, request: Dict) -> Dict:
 with torch.no_grad():
 try:
 prompt = request.pop("prompt")
 data = self.pipeline(
 prompt,
 eos_token_id=self.tokenizer.eos_token_id,
 max_length=DEFAULT_MAX_LENGTH,
 **request
 )[0]
 return {"data": data}
 
 except Exception as exc:
 return {"status": "error", "data": None, "message": str(exc)}

Esto es lo que está pasando:

• MODEL_NAME es el modelo que vamos a utilizar, en nuestro caso el modelo falcon-7b-instruct
• Dentro de la carga, descargamos el modelo de 8 bits del sitio web oficial de HuggingFace. La razón por la que queremos 8 bits es que el modelo usa significativamente menos memoria en la GPU cuando se cuantifica.
• Además, si desea ejecutar el modelo de forma nativa en una GPU con menos de 13 GB de VRAM, deberá cargar el modelo en 8 bits.
• La función de predicción acepta una solicitud JSON como argumento e invoca el modelo mediante self.pipeline. torch.no_grad le dice a Pytorch que estamos en modo de inferencia, no en modo de entrenamiento. ¡Es genial! Eso es todo lo que necesitamos para configurar nuestro modelo.

Paso 2: Ejecute el modelo localmente (opcional)

Si tiene una GPU Nvidia con más de 8 GB de VRAM, puede ejecutar el modelo localmente.

Si no, continúe con el siguiente paso.

Necesitamos descargar más dependencias para ejecutar el modelo localmente. Antes de descargar las dependencias, debe asegurarse de tener CUDA y el controlador CUDA correcto instalado.

Debido a que estábamos tratando de ejecutar el modelo localmente, Truss no pudo ayudarnos a administrar el poder de CUDA.

pip install transformers
pip install torch
pip install peft
pip install bitsandbytes
pip install einops
pip install scipy 

Luego, en el script main.py creado fuera del directorio falcon_7b_truss, necesitamos cargar nuestro Truss.

El siguiente es el código de main.py:

import truss
from pathlib import Path
import requests
tr = truss.load("./falcon_7b_truss")
output = tr.predict({"prompt": "Hi there how are you?"})
print(output)

Esto es lo que está pasando:

• Si recuerda, el directorio falcon_7b_truss fue creado automáticamente por Truss. Podemos cargar todo el paquete incluyendo modelos y dependencias usando truss.load
• Una vez que hayamos cargado nuestro paquete, simplemente podemos llamar al método de predicción para obtener el resultado del modelo y ejecutar main.py para obtener el resultado del modelo. El tamaño de este archivo de modelo es de aproximadamente 15 GB, por lo que la descarga del modelo puede demorar entre 5 y 10 minutos. Después de ejecutar el script, debería ver un resultado como este:

• {'data': {'generated_text': "Hi there how are you?\nI'm doing well. I'm in the middle of a move, so I'm a bit tired. I'm also a bit overwhelmed. I'm not sure how to get started. I'm not sure what I'm doing. I'm not sure if I'm doing it right. I'm not sure if I'm doing it wrong. I'm not sure if I'm doing it at all.\nI'm not sure if I'm doing it right. I'm not sure if I'm doing it wrong. I"}}

Paso 3: Empaquetar el modelo con Docker

Por lo general, cuando las personas colocan un modelo en un contenedor, toman las dependencias binarias y de Python del modelo y lo empaquetan con Flask o un servidor Fast API.

Mucho de esto es repetitivo y no tenemos que preocuparnos. Truss maneja estas tareas automáticamente. Hemos proporcionado el modelo y Truss creará el servidor, por lo que lo único que queda por hacer es proporcionar las dependencias de Python.

config.yaml contiene la configuración de nuestro modelo. Aquí es donde podemos agregar dependencias a nuestros modelos. El archivo de configuración ya proporciona la mayor parte de lo que necesitamos, pero aún necesitamos agregar algunas cosas.

Esto es lo que necesita agregar a su config.yaml:

apply_library_patches: true
bundled_packages_dir: packages
data_dir: data
description: null
environment_variables: {}
examples_filename: examples.yaml
external_package_dirs: []
input_type: Any
live_reload: false
model_class_filename: model.py
model_class_name: Model
model_framework: custom
model_metadata: {}
model_module_dir: model
model_name: Falcon-7B
model_type: custom
python_version: py39
requirements:
- torch
- peft
- sentencepiece
- accelerate
- bitsandbytes
- einops
- scipy
- git+https://github.com/huggingface/transformers.git
resources:
 use_gpu: true
 cpu: "3"
 memory: 14Gi
secrets: {}
spec_version: '2.0'
system_packages: []

Entonces, las cosas principales que agregamos están relacionadas con los requisitos. Todas las dependencias enumeradas son necesarias para descargar y ejecutar el modelo.

Otra cosa importante que añadimos fueron los recursos. use_gpu:true es muy importante porque le dice a Truss que cree un Dockerfile para nosotros con la compatibilidad con GPU habilitada. Esto es para tareas de configuración.

A continuación, pondremos en contenedores nuestro modelo. Si no sabe cómo empaquetar su modelo con Docker, no se preocupe, Truss lo tiene cubierto.

En el archivo main.py, le diremos a Truss que empaquete todo junto. Aquí está el código que necesita:

import truss
from pathlib import Path
import requests
tr = truss.load("./falcon_7b_truss")
command = tr.docker_build_setup(build_dir=Path("./falcon_7b_truss"))
print(command)

qué pasó:

• Primero, cargamos falcon_7b_truss.
• Luego, la función docker_build_setup maneja todas las cosas complicadas como crear el Dockerfile y configurar el servidor Fast API.
• Si busca en su directorio falcon_7b_truss, verá que se generan más archivos. No tenemos que preocuparnos por cómo funcionan estos archivos, ya que todos se administrarán en segundo plano.
• Al final de la ejecución, obtenemos un comando de Docker para construir nuestra imagen de Docker:

docker build falcon_7b_truss -t falcon-7b-model:latest

Si desea crear una imagen de Docker, continúe y ejecute el comando de compilación. La imagen tiene un tamaño aproximado de 9 GB, por lo que puede llevar un tiempo construirla. Si no desea construirlo, pero quiere seguir leyendo, puede echar un vistazo más de cerca a las imágenes que proporcioné:

htrivedi05/truss-falcon-7b:latest .

Si crea la imagen usted mismo, debe etiquetarla y enviarla a dockerhub para que nuestros contenedores en la nube puedan extraer la imagen. Estos son los comandos que deben ejecutarse después de construir la imagen:

docker tag falcon-7b-model <docker_user_id>/falcon-7b-model
docker push <docker_user_id>/falcon-7b-model

¡Sorprendentemente, en este punto estamos listos para ejecutar nuestro modelo en la nube!

[Descripción] Los siguientes pasos opcionales (antes del paso 4) se usan para ejecutar la imagen localmente usando la GPU.

Si tiene una GPU Nvidia y desea ejecutar un modelo en contenedores de forma local con compatibilidad con GPU, debe asegurarse de que Docker esté configurado para usar su GPU.

Para hacer esto, todo lo que necesita es abrir una terminal y ejecutar el siguiente comando:

distributinotallow=$(. /etc/os-release;echo $ID$VERSION_ID) && curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add - && curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

apt-get update
apt-get install -y nvidia-docker2

sudo systemctl restart docker

Ahora que su Docker está configurado para acceder a la GPU, así es como se ejecuta el contenedor:

docker run --gpus all -d -p 8080:8080 falcon-7b-model

Nuevamente, tomará un tiempo descargar el modelo. Para asegurarse de que todo funciona, puede verificar los registros del contenedor y debería ver "LA INFERENCIA DEL DISPOSITIVO SE ESTÁ EJECUTANDO ES: cuda".

Puede realizar llamadas al modelo a través del extremo de la API de la siguiente manera:

import requests

data = {"prompt": "Hi there, how's it going?"}
res = requests.post("http://127.0.0.1:8080/v1/models/model:predict", jsnotallow=data)
print(res.json())

Paso 4: implementar el modelo en producción

Estoy usando la palabra "producción" bastante vagamente aquí. Ejecutaremos nuestro modelo en Kubernetes porque puede escalar y manejar fácilmente cantidades variables de tráfico en este entorno.

Dicho esto, Kubernetes proporciona mucha configuración, como políticas de red, almacenamiento, mapas de configuración, equilibrio de carga, gestión de secretos, etc.

Aunque Kubernetes se creó para "escalar" y ejecutar cargas de trabajo de "producción", muchas de las configuraciones de nivel de producción que necesita no están disponibles de manera inmediata. Una discusión que cubra esos temas avanzados de Kubernetes está más allá del alcance de este artículo y es una distracción de lo que estamos tratando de lograr aquí. Entonces, para esta publicación de blog, crearemos un clúster mínimo del tipo básico.

Sin más preámbulos, ¡vamos a crear nuestro clúster!

requisitos previos:

1. Tener una cuenta de Google Cloud correspondiente que creó un proyecto
2. CLI de gcloud instalado correctamente en su computadora
3. Asegúrese de tener suficiente cuota para ejecutar su computadora habilitada para GPU. Puede verificar sus cuotas en el grupo de comandos "IAM y administración".

Crea nuestro clúster de GKE

Usaremos Kubernetes Engine de Google para crear y administrar nuestro clúster. Obtenga información importante a continuación:

Kubernetes Engine de Google no es gratuito. Google no nos dejará usar una potente GPU de forma gratuita. Dicho esto, estamos creando un clúster de un solo nodo con GPU menos potentes. Este experimento no debería costar más de $1 a $2.

Esta es la configuración del clúster de Kubernetes en el que nos ejecutaremos:

• 1 nodo, clúster estándar de Kubernetes
• 1 GPU Nvidia T4
• Máquina n1-estándar-4 (4 vCPU, 15 GB de memoria)
• Todo esto se ejecutará en una instancia de spot

Nota: si se encuentra en otra región y no tiene acceso al mismo recurso, siéntase libre de editarlo.

Pasos para crear un clúster:

1. Vaya a Google Cloud Console y busque un servicio llamado Kubernetes Engine:

2. Haga clic en el botón "CREAR":

• Asegúrese de crear un clúster estándar, no un clúster de piloto automático. Debería decir "Crear un clúster de kubernetes" en la parte superior de la página.

3. Fundación del clúster:

• En la pestaña "Conceptos básicos del clúster", no queremos hacer demasiados cambios. Simplemente asigne un nombre al clúster. No es necesario cambiar regiones ni controlar planos.

4. Haga clic en la pestaña del grupo predeterminado y cambie el número de nodos a 1.

5. En la pestaña "grupo predeterminado", haga clic en la pestaña "Nodos" en la barra lateral izquierda:

• Cambiar la configuración de la máquina (uso general) de uso general a GPU
• Seleccione Nvidia T4 como tipo de GPU y establezca la cantidad en 1
• Habilite el tiempo compartido de GPU (aunque no usaremos esta función)
• Establezca el número máximo de clientes compartidos por GPU en 8
• Para el tipo de máquina, elija n1-standard-4 (4 vCPU, 15 GB de memoria)
• Cambiar el tamaño del disco de arranque a 50
• Desplácese hasta el final y marque la casilla que dice: Habilitar nodos en máquinas virtuales puntuales

Una vez configurado el clúster, continúe y cree el clúster.

Google tarda unos minutos en configurar todo. Una vez que su clúster esté en funcionamiento, debemos conectarnos a él. Para hacer esto, abre tu terminal y ejecuta el siguiente comando:

gcloud config set compute/zone us-central1-c
gcloud container clusters get-credentials gpu-cluster-1

Si usó diferentes zonas de nombre de clúster, actualice esas zonas en consecuencia. Para comprobar que estamos conectados ejecutamos el siguiente comando:

kubectl get nodes

Debería ver aparecer 1 nodo en su terminal. Aunque nuestro clúster tiene una GPU, le faltan algunos controladores de Nvidia que debemos instalar. Afortunadamente, instalarlos es muy fácil. Ejecute el siguiente comando para instalar el controlador:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

Celebremos, finalmente estamos listos para implementar nuestro modelo.

modelo de despliegue

Para implementar nuestro modelo en un clúster, debemos crear una implementación de Kubernetes. Las implementaciones de Kubernetes nos permiten administrar instancias del modelo en contenedores. Aquí, no discutiré Kubernetes o cómo escribir archivos yaml en profundidad, porque esto está más allá del alcance del tema de este artículo.

Debe crear un archivo llamado truss-falcon-deployment.yaml. Abra ese archivo y pegue lo siguiente:

apiVersion: apps/v1
kind: Deployment
metadata:
 name: truss-falcon-7b
 namespace: default
spec:
 replicas: 1
 selector:
 matchLabels:
 component: truss-falcon-7b-layer
 template:
 metadata:
 labels:
 component: truss-falcon-7b-layer
 spec:
 containers:
 - name: truss-falcon-7b-container
 image: <your_docker_id>/falcon-7b-model:latest
 ports:
 - containerPort: 8080
 resources:
 limits:
 nvidia.com/gpu: 1
---
apiVersion: v1
kind: Service
metadata:
 name: truss-falcon-7b-service
 namespace: default
spec:
 type: ClusterIP
 selector:
 component: truss-falcon-7b-layer
 ports:
 - port: 8080
 protocol: TCP
 targetPort: 8080

qué pasó:

• Le decimos a Kubernetes que queremos crear pods con nuestra imagen del modelo falcon-7b. Asegúrese de reemplazar <your_docker_id> con su ID real. Si no creó su propia imagen de Docker y quiere usar la mía, reemplácela con la siguiente: htrivedi05/truss-falcon-7b:latest.
• Habilitamos el acceso GPU para contenedores estableciendo un límite de recursos nvidia.com/GPU:1. Esto le dice a Kubernetes que solicite solo una GPU para nuestro contenedor.
• Para poder interactuar con nuestro modelo, necesitamos crear un servicio de Kubernetes que se ejecutará en el puerto 8080.

Cree una implementación ejecutando el siguiente comando en una terminal:

kubectl create -f truss-falcon-deployment.yaml

Si ejecuta este comando:

kubectl get deployments

Debería ver una pantalla similar a la siguiente:

NAME READY UP-TO-DATE AVAILABLE AGE
truss-falcon-7b 0/1 1 0 8s

La implementación tardará unos minutos en cambiar al estado listo. Recuerde que el modelo debe descargarse desde la página de HuggingFace cada vez que se reinicia el contenedor. Puede verificar el progreso del contenedor ejecutando:

kubectl get pods
 
kubectl logs truss-falcon-7b-8fbb476f4-bggts

Cambie el nombre del pod en consecuencia.

Debe buscar lo siguiente en los registros:

• Busque la declaración de impresión EN LA QUE SE ESTÁ EJECUTANDO LA INFERENCIA DEL DISPOSITIVO ES: cuda. Esto confirma que nuestro contenedor está correctamente conectado a la GPU.

A continuación, debería ver algunas declaraciones impresas sobre el archivo del modelo que se está descargando.

Downloading (…)model.bin.index.json: 100%|██████████| 16.9k/16.9k [00:00<00:00, 1.92MB/s]
Downloading (…)l-00001-of-00002.bin: 100%|██████████| 9.95G/9.95G [02:37<00:00, 63.1MB/s]
Downloading (…)l-00002-of-00002.bin: 100%|██████████| 4.48G/4.48G [01:04<00:00, 69.2MB/s]
Downloading shards: 100%|██████████| 2/2 [03:42<00:00, 111.31s/it][01:04<00:00, 71.3MB/s]

Después de descargar el modelo y crear el microservicio, debería ver el siguiente resultado al final del registro:

{"asctime": "2023-06-29 21:40:40,646", "levelname": "INFO", "message": "Completed model.load() execution in 330588 ms"}

A partir de este mensaje, podemos confirmar que el modelo está cargado y listo para las tareas de inferencia.

modelo de razonamiento

No podemos llamar al modelo directamente; en su lugar, debemos llamar al servicio del modelo.

Puede obtener el nombre del servicio ejecutando el siguiente comando:

kubectl get svc

La salida es la siguiente:

AME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes ClusterIP 10.80.0.1 <none> 443/TCP 46m
truss-falcon-7b-service ClusterIP 10.80.1.96 <none> 8080/TCP 6m19s

Lo que queremos llamar es el servicio truss-falcon-7b. Para que el servicio sea accesible, debemos reenviarlo con el siguiente comando:

kubectl port-forward svc/truss-falcon-7b-service 8080

La salida es la siguiente:

Forwarding from 127.0.0.1:8080 -> 8080
Forwarding from [::1]:8080 -> 8080

Hermoso, nuestro modelo se sirve como punto final de API REST en 127.0.0.1:8080. Abra cualquier secuencia de comandos de Python, como main.py, y ejecute el siguiente código:

import requests

data = {"prompt": "Whats the most interesting thing about a falcon?"}
res = requests.post("http://127.0.0.1:8080/v1/models/model:predict", jsnotallow=data)
print(res.json())

La salida es la siguiente:

{'data': {'generated_text': 'Whats the most interesting thing about a falcon?\nFalcons are known for their incredible speed and agility in the air, as well as their impressive hunting skills. They are also known for their distinctive feathering, which can vary greatly depending on the species.'}}

¡Guau! ¡Hemos contenedorizado con éxito el modelo Falcon 7B y lo hemos implementado con éxito como un microservicio en producción!

Siéntase libre de usar diferentes sugerencias para ver qué devuelve el modelo.

Cerrar el clúster

Una vez que esté satisfecho con su Falcon 7B, puede eliminar su implementación ejecutando:

kubectl delete -f truss-falcon-deployment.yaml

A continuación, vaya a Kubernetes Engine en Google Cloud y elimine el clúster de Kubernetes.

Nota: A menos que se indique lo contrario, todas las imágenes de este artículo son proporcionadas por el propio autor.

en conclusión

Aunque no es fácil ejecutar y administrar un modelo de nivel de producción como ChatGPT, sin embargo, los desarrolladores pueden implementar mejor sus propios modelos en la nube con el tiempo.

En esta publicación de blog, cubrimos todo lo necesario para implementar LLM en producción a un nivel básico. En resumen, primero debemos empaquetar el modelo con Truss, luego contenerlo con Docker y finalmente implementarlo en la nube con Kubernetes. Sé que hay mucho que hacer en detalle, y aunque no fue lo más fácil del mundo, lo hicimos de todos modos.

En conclusión, espero que hayas aprendido algo interesante de esta publicación de blog. ¡Gracias por leer!

---

Ver más herramientas geniales

Ascensores espaciales, MOSS, ChatGPT, etc., todos indican que 2023 no está destinado a ser un año ordinario. Cualquier nueva tecnología es digna de escrutinio, y deberíamos tener esta sensibilidad.

En los últimos años, me he encontrado vagamente con código bajo, y es relativamente popular en la actualidad, y muchos de los principales fabricantes se han unido uno tras otro.

Concepto de plataforma de código bajo: a través de la generación automática de código y la programación visual, solo se necesita una pequeña cantidad de código para construir varias aplicaciones rápidamente.

Lo que es low-code, en mi opinión, es la operación de arrastrar, zumbar y una sola pasada para crear un sistema que pueda ejecutar, front-end, back-end y base de datos, todo de una sola vez. Por supuesto, este puede ser el objetivo final.

Enlace: www.jnpfsoft.com/?csdn, si está interesado, pruébelo también.

La ventaja de JNPF es que puede generar códigos front-end y back-end, lo que brinda una gran flexibilidad y puede crear aplicaciones más complejas y personalizadas. Su diseño arquitectónico también permite a los desarrolladores centrarse en el desarrollo de la lógica de la aplicación y la experiencia del usuario sin preocuparse por los detalles técnicos subyacentes.