Entrega LLM escalables en GKE con TorchServe

En este instructivo, se muestra cómo entregar un modelo de aprendizaje automático (AA) de PyTorch entrenado con anterioridad en un clúster de GKE con el framework de TorchServe para entrega escalable. El modelo de AA que se usa en este instructivo genera predicciones basadas en las solicitudes de los usuarios. Puedes usar la información de este instructivo para implementar y entregar tus propios modelos a gran escala en GKE.

Acerca de la aplicación del instructivo

La aplicación es una pequeña aplicación web de Python creada con el framework de Fast Dash. Usa la aplicación para enviar solicitudes de predicción al modelo T5. Esta aplicación captura las entradas de texto del usuario y los pares de idiomas, y envía la información al modelo. El modelo traduce el texto y muestra el resultado a la aplicación, que lo muestra al usuario. Para obtener más información sobre Fast Dash, consulta la documentación de Fast Dash.

Cómo funciona

En este instructivo, se implementan las cargas de trabajo en un clúster de GKE Autopilot. GKE administra completamente los nodos de Autopilot, lo que reduce la sobrecarga administrativa para la configuración, el escalamiento y las actualizaciones de los nodos. Cuando implementas la carga de trabajo y la aplicación de AA en Autopilot, GKE elige el tipo y el tamaño de máquina subyacentes correctos para ejecutar las cargas de trabajo. Para obtener más información, consulta la descripción general de Autopilot.

Después de implementar el modelo, obtendrás una URL de predicción que tu aplicación puede usar para enviar solicitudes de predicción al modelo. Este método separa el modelo de la aplicación, lo que permite que este escale de forma independiente de la aplicación web.

Objetivos

  • Prepara un modelo T5 previamente entrenado del repositorio de Hugging Face para entregarlo. Para ello, empaquétalo como una imagen de contenedor y envíalo a Artifact Registry.
  • Implementa el modelo en un clúster de Autopilot
  • Implementa la aplicación Fast Dash que se comunica con el modelo
  • Escala automáticamente el modelo según las métricas de Prometheus

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. Install the Google Cloud CLI.

  3. To initialize the gcloud CLI, run the following command: 

    gcloud init

  4. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  5. Make sure that billing is enabled for your Google Cloud project.

  6. Enable the Kubernetes Engine, Cloud Storage, Artifact Registry, and Cloud Build APIs: 

    gcloud services enable container.googleapis.com storage.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com
  7. Install the Google Cloud CLI.

  8. To initialize the gcloud CLI, run the following command: 

    gcloud init

  9. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  10. Make sure that billing is enabled for your Google Cloud project.

  11. Enable the Kubernetes Engine, Cloud Storage, Artifact Registry, and Cloud Build APIs: 

    gcloud services enable container.googleapis.com storage.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com

Prepare el entorno

Clona el repositorio de ejemplo y abre el directorio del instructivo:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/ai-ml/t5-model-serving

Crea el clúster

Ejecuta el siguiente comando:

gcloud container clusters create-auto ml-cluster \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=CLUSTER_VERSION \
    --location=us-central1

Reemplaza lo siguiente:

  • RELEASE_CHANNEL: Es el canal de versiones del clúster. Debe ser rapid, regular o stable. Elige un canal que tenga la versión 1.28.3-gke.1203000 de GKE o una posterior para usar las GPU L4. Para ver las versiones disponibles en un canal específico, consulta Visualiza las versiones predeterminadas y disponibles para los canales de versiones.
  • CLUSTER_VERSION: la versión de GKE que se usará. Debe ser 1.28.3-gke.1203000 o una versión posterior.

Esta operación tarda varios minutos en completarse.

Crea un repositorio de Artifact Registry

  1. Crea un repositorio estándar nuevo de Artifact Registry con el formato Docker en la misma región que tu clúster:

    gcloud artifacts repositories create models \
    --repository-format=docker \
    --location=us-central1 \
    --description="Repo for T5 serving image"

  2. Verifica el nombre del repositorio:

    gcloud artifacts repositories describe models \
    --location=us-central1

    El resultado es similar al siguiente:

    Encryption: Google-managed key
Repository Size: 0.000MB
createTime: '2023-06-14T15:48:35.267196Z'
description: Repo for T5 serving image
format: DOCKER
mode: STANDARD_REPOSITORY
name: projects/PROJECT_ID/locations/us-central1/repositories/models
updateTime: '2023-06-14T15:48:35.267196Z'

Empaqueta el modelo

En esta sección, empaquetas el modelo y el framework de entrega en una sola imagen de contenedor con Cloud Build y envías la imagen resultante al repositorio de Artifact Registry.

  1. Revisa el Dockerfile para la imagen de contenedor:

    # Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

ARG BASE_IMAGE=pytorch/torchserve:0.7.1-cpu

FROM alpine/git

ARG MODEL_NAME=t5-small
ARG MODEL_REPO=https://huggingface.co/${MODEL_NAME}
ENV MODEL_NAME=${MODEL_NAME}
ENV MODEL_VERSION=${MODEL_VERSION}

RUN git clone "${MODEL_REPO}" /model

FROM ${BASE_IMAGE}

ARG MODEL_NAME=t5-small
ARG MODEL_VERSION=1.0
ENV MODEL_NAME=${MODEL_NAME}
ENV MODEL_VERSION=${MODEL_VERSION}

COPY --from=0 /model/. /home/model-server/
COPY handler.py \
     model.py \
     requirements.txt \
     setup_config.json /home/model-server/

RUN  torch-model-archiver \
     --model-name="${MODEL_NAME}" \
     --version="${MODEL_VERSION}" \
     --model-file="model.py" \
     --serialized-file="pytorch_model.bin" \
     --handler="handler.py" \
     --extra-files="config.json,spiece.model,tokenizer.json,setup_config.json" \
     --runtime="python" \
     --export-path="model-store" \
     --requirements-file="requirements.txt"

FROM ${BASE_IMAGE}

ENV PATH /home/model-server/.local/bin:$PATH
ENV TS_CONFIG_FILE /home/model-server/config.properties
# CPU inference will throw a warning cuda warning (not error)
# Could not load dynamic library 'libnvinfer_plugin.so.7'
# This is expected behaviour. see: https://stackoverflow.com/a/61137388
ENV TF_CPP_MIN_LOG_LEVEL 2

COPY --from=1 /home/model-server/model-store/ /home/model-server/model-store
COPY config.properties /home/model-server/

    Este Dockerfile define el siguiente proceso de compilación de varias etapas:

    1. Descarga los artefactos del modelo del repositorio de Hugging Face.
    2. Empaqueta el modelo con la herramienta PyTorch Serving Archive. Esto crea un archivo de modelo (.mar) que el servidor de inferencia usa para cargar el modelo.
    3. Compila la imagen final con PyTorch Serve.

  2. Compila y envía la imagen mediante Cloud Build:

    gcloud builds submit model/ \
    --region=us-central1 \
    --config=model/cloudbuild.yaml \
    --substitutions=_LOCATION=us-central1,_MACHINE=gpu,_MODEL_NAME=t5-small,_MODEL_VERSION=1.0

    La finalización del proceso de compilación toma varios minutos. Si usas un tamaño de modelo mayor que t5-small, el proceso de compilación puede tomar mucho más tiempo.

  3. Verifica que la imagen esté en el repositorio:

    gcloud artifacts docker images list us-central1-docker.pkg.dev/PROJECT_ID/models

    Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

    El resultado es similar al siguiente:

    IMAGE                                                     DIGEST         CREATE_TIME          UPDATE_TIME
us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small     sha256:0cd...  2023-06-14T12:06:38  2023-06-14T12:06:38

Implementa el modelo empaquetado en GKE

A fin de implementar la imagen, modifica el manifiesto de Kubernetes en el repositorio de ejemplo para que coincida con tu entorno.

  1. Revisa el manifiesto para la carga de trabajo de inferencia:

    # Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: t5-inference
  labels:
    model: t5
    version: v1.0
    machine: gpu
spec:
  replicas: 1
  selector:
    matchLabels:
      model: t5
      version: v1.0
      machine: gpu
  template:
    metadata:
      labels:
        model: t5
        version: v1.0
        machine: gpu
    spec:
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
      securityContext:
        fsGroup: 1000
        runAsUser: 1000
        runAsGroup: 1000
      containers:
        - name: inference
          image: us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small:1.0-gpu
          imagePullPolicy: IfNotPresent
          args: ["torchserve", "--start", "--foreground"]
          resources:
            limits:
              nvidia.com/gpu: "1"
              cpu: "3000m"
              memory: 16Gi
              ephemeral-storage: 10Gi
            requests:
              nvidia.com/gpu: "1"
              cpu: "3000m"
              memory: 16Gi
              ephemeral-storage: 10Gi
          ports:
            - containerPort: 8080
              name: http
            - containerPort: 8081
              name: management
            - containerPort: 8082
              name: metrics
          readinessProbe:
            httpGet:
              path: /ping
              port: http
            initialDelaySeconds: 120
            failureThreshold: 10
          livenessProbe:
            httpGet:
              path: /models/t5-small
              port: management
            initialDelaySeconds: 150
            periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: t5-inference
  labels:
    model: t5
    version: v1.0
    machine: gpu
spec:
  type: ClusterIP
  selector:
    model: t5
    version: v1.0
    machine: gpu
  ports:
    - port: 8080
      name: http
      targetPort: http
    - port: 8081
      name: management
      targetPort: management
    - port: 8082
      name: metrics
      targetPort: metrics

  2. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

    sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/serving-gpu.yaml"

    Esto garantiza que la ruta de la imagen de contenedor en la especificación del Deployment coincida con la ruta a la imagen del modelo T5 en Artifact Registry.

  3. Crea los recursos de Kubernetes:

    kubectl create -f kubernetes/serving-gpu.yaml

Para verificar que el modelo se haya implementado correctamente, haz lo siguiente:

  1. Obtén el estado del Deployment y el Service:

    kubectl get -f kubernetes/serving-gpu.yaml

    Espera hasta que el resultado muestre los Pods listos, similar a lo siguiente. Según el tamaño de la imagen, la primera extracción de imagen puede tardar varios minutos.

    NAME                            READY   UP-TO-DATE    AVAILABLE   AGE
deployment.apps/t5-inference    1/1     1             0           66s

NAME                    TYPE        CLUSTER-IP        EXTERNAL-IP   PORT(S)                       AGE
service/t5-inference    ClusterIP   10.48.131.86    <none>        8080/TCP,8081/TCP,8082/TCP    66s

  2. Abre un puerto local para el Service t5-inference:

    kubectl port-forward svc/t5-inference 8080

  3. Abre una ventana de la terminal nueva y envía una solicitud de prueba al Service:

    curl -v -X POST -H 'Content-Type: application/json' -d '{"text": "this is a test sentence", "from": "en", "to": "fr"}' "http://localhost:8080/predictions/t5-small/1.0"

    Si la solicitud de prueba falla y la conexión del Pod se cierra, verifica los registros:

    kubectl logs deployments/t5-inference

    Si el resultado es similar al siguiente, TorchServe no pudo instalar algunas dependencias del modelo:

    org.pytorch.serve.archive.model.ModelException: Custom pip package installation failed for t5-small

    Para resolver este problema, reinicia el Deployment:

    kubectl rollout restart deployment t5-inference

    El controlador del Deployment crea un Pod nuevo. Repite los pasos anteriores para abrir un puerto en el Pod nuevo.

Accede al modelo implementado con la aplicación web

  1. Compila y envía la aplicación web Fast Dash como una imagen de contenedor en Artifact Registry:

    gcloud builds submit client-app/ \
    --region=us-central1 \
    --config=client-app/cloudbuild.yaml

  2. Abre kubernetes/application.yaml en un editor de texto y reemplaza PROJECT_ID en el campo image: por el ID del proyecto. Como alternativa, ejecuta el siguiente comando:

    sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/application.yaml"

  3. Crea los recursos de Kubernetes:

    kubectl create -f kubernetes/application.yaml

    El Deployment y el Service pueden tardar un tiempo en aprovisionarse por completo.

  4. Para verificar el estado, ejecuta el siguiente comando:

    kubectl get -f kubernetes/application.yaml

    Espera hasta que el resultado muestre los Pods listos, similar a lo siguiente:

    NAME                       READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/fastdash   1/1     1            0           1m

NAME               TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
service/fastdash   NodePort   203.0.113.12    <none>        8050/TCP         1m

  5. La aplicación web ahora se está ejecutando, aunque no está expuesta en una dirección IP externa. Para acceder a la aplicación web, abre un puerto local:

    kubectl port-forward service/fastdash 8050

  6. En un navegador, abre la interfaz web:

    • Si usas una shell local, abre un navegador y ve a http://127.0.0.1:8050.
    • Si usas Cloud Shell, haz clic en Vista previa en la Web y, luego, en Cambiar puerto. Especifica el puerto 8050.

  7. Para enviar una solicitud al modelo T5, especifica los valores en los campos TEXTO, DE IDIOMA y A IDIOMA en la interfaz web y haz clic en Enviar. Para obtener una lista de los idiomas disponibles, consulta la documentación de T5.

Habilita el ajuste de escala automático para el modelo

En esta sección, se muestra cómo habilitar el ajuste de escala automático para el modelo según las métricas de Google Cloud Managed Service para Prometheus mediante los siguientes pasos:

  1. Instala el adaptador de Stackdriver para métricas personalizadas
  2. Aplica parámetros de configuración de PodMonitoring y HorizontalPodAutoscaling

Google Cloud Managed Service para Prometheus está habilitado de forma predeterminada en los clústeres de Autopilot que ejecutan la versión 1.25 y posteriores.

Instala el adaptador de Stackdriver para métricas personalizadas

Este adaptador permite que tu clúster use métricas de Prometheus para tomar decisiones sobre el ajuste de escala automático de Kubernetes.

  1. Implementa el adaptador:

    kubectl create -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

  2. Crea una cuenta de servicio de IAM para que la use el adaptador:

    gcloud iam service-accounts create monitoring-viewer

  3. Otorga a la cuenta de servicio de IAM el rol monitoring.viewer en el proyecto y el rol iam.workloadIdentityUser:

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com" \
    --role roles/monitoring.viewer
gcloud iam service-accounts add-iam-policy-binding monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"

    Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

  4. Anota la cuenta de servicio de Kubernetes del adaptador para permitir que actúe en nombre de la cuenta de servicio de IAM:

    kubectl annotate serviceaccount custom-metrics-stackdriver-adapter \
    --namespace custom-metrics \
    iam.gke.io/gcp-service-account=monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com

  5. Reinicia el adaptador para propagar los cambios:

    kubectl rollout restart deployment custom-metrics-stackdriver-adapter \
    --namespace=custom-metrics

Aplica parámetros de configuración de PodMonitoring y HorizontalPodAutoscaling

PodMonitoring es un recurso personalizado de Google Cloud Managed Service para Prometheus que permite la transferencia de métricas y la recopilación de objetivos en un espacio de nombres específico.

  1. Implementa el recurso PodMonitoring en el mismo espacio de nombres que el Deployment TorchServe:

    kubectl apply -f kubernetes/pod-monitoring.yaml

  2. Revisa el manifiesto de HorizontalPodAutoscaler:

    # Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: t5-inference
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: t5-inference
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: prometheus.googleapis.com|ts_queue_latency_microseconds|counter
      target:
        type: AverageValue
        averageValue: "30000"

    El HorizontalPodAutoscaler escala la cantidad de Pods del modelo T5 en función de la duración acumulativa de la cola de solicitudes. El ajuste de escala automático se basa en la métrica ts_queue_latency_microseconds, que muestra la duración acumulativa de la cola en microsegundos.

  3. Crea el HorizontalPodAutoscaler:

    kubectl apply -f kubernetes/hpa.yaml

Verifica el ajuste de escala automático con un generador de cargas

A fin de probar tu configuración del ajuste de escala automático, genera carga para la aplicación de entrega. En este instructivo, se usa un generador de cargas de Locust para enviar solicitudes al extremo de predicción del modelo.

  1. Crea el generador de cargas:

    kubectl apply -f kubernetes/loadgenerator.yaml

    Espera a que los Pods del generador de cargas estén listos.

  2. Expón de manera local la interfaz web del generador de cargas:

    kubectl port-forward svc/loadgenerator 8080

    Si ves un mensaje de error, vuelve a intentarlo cuando el Pod se esté ejecutando.

  3. En un navegador, abre la interfaz web del generador de cargas:

    • Si usas una shell local, abre un navegador y ve a http://127.0.0.1:8080.
    • Si usas Cloud Shell, haz clic en Vista previa en la Web y, luego, en Cambiar puerto. Ingresa el puerto 8080.

  4. Haz clic en la pestaña Charts para observar el rendimiento en el tiempo.

  5. Abre una ventana de la terminal nueva y observa el recuento de réplicas de los escaladores automáticos horizontales de Pods:

    kubectl get hpa -w

    La cantidad de réplicas aumenta a medida que aumenta la carga. El escalamiento vertical puede tardar aproximadamente diez minutos. A medida que se inician réplicas nuevas, la cantidad de solicitudes exitosas en el chart de Locust aumenta.

    NAME           REFERENCE                 TARGETS           MINPODS   MAXPODS   REPLICAS   AGE
t5-inference   Deployment/t5-inference   71352001470m/7M   1         5        1           2m11s

Recomendaciones

  • Compila tu modelo con la misma versión de la imagen base de Docker que usarás para la entrega.
  • Si tu modelo tiene dependencias de paquetes especiales o si el tamaño de tus dependencias es grande, crea una versión personalizada de tu imagen de Docker base.
  • Mira la versión de árbol de los paquetes de dependencia del modelo. Asegúrate de que las dependencias de tus paquetes sean compatibles con las versiones de las demás. Por ejemplo, la versión 2.0.3 de Panda es compatible con NumPy versión 1.20.3 y posteriores.
  • Ejecuta modelos con uso intensivo de GPU en nodos de GPU y modelos con uso intensivo de CPU en CPU. Esto podría mejorar la estabilidad de la entrega del modelo y garantizar que consumas los recursos de nodo de manera eficiente.

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

    Delete a Google Cloud project:

    gcloud projects delete PROJECT_ID

Borra los recursos individuales

  1. Borra los recursos de Kubernetes:

    kubectl delete -f kubernetes/loadgenerator.yaml
kubectl delete -f kubernetes/hpa.yaml
kubectl delete -f kubernetes/pod-monitoring.yaml
kubectl delete -f kubernetes/application.yaml
kubectl delete -f kubernetes/serving-gpu.yaml
kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

  2. Borra el clúster de GKE:

    gcloud container clusters delete "ml-cluster" \
    --location="us-central1" --quiet

  3. Borra la cuenta de servicio de IAM y las vinculaciones de políticas de IAM:

    gcloud projects remove-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com" \
    --role roles/monitoring.viewer
gcloud iam service-accounts remove-iam-policy-binding monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"
gcloud iam service-accounts delete monitoring-viewer

  4. Borra las imágenes en Artifact Registry. De manera opcional, borra todo el repositorio. Para obtener instrucciones, consulta la documentación de Artifact Registry sobre cómo borrar imágenes.

Descripción general de los componentes

En esta sección, se describen los componentes usados en este instructivo, como el modelo, la aplicación web, el framework y el clúster.

Acerca del modelo T5

En este instructivo, se usa un modelo T5 multilingüe previamente entrenado. T5 es un transformador de texto a texto que convierte texto de un idioma a otro. En T5, las entradas y salidas siempre son cadenas de texto, a diferencia de los modelos de estilo BERT que solo pueden generar una etiqueta de clase o un intervalo de la entrada. El modelo T5 también se puede usar para tareas como resúmenes, preguntas y respuestas o clasificación de texto. El modelo se entrena con una gran cantidad de texto de Colossal Clean Crawled Corpus (C4) y Wiki-DPR.

Para obtener más información, consulta la documentación del modelo T5.

Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li y Peter J. Liu presentó el modelo T5 en Exploring the Libraries of Transfer Learning with a Unified Text-to-Text Transformer, publicado en el Journal of Machine Learning Research.

El modelo T5 admite varios tamaños de modelos, con diferentes niveles de complejidad que se adaptan a casos de uso específicos. En este instructivo, se usa el tamaño predeterminado, t5-small, pero también puedes elegir uno diferente. Los siguientes tamaños de T5 se distribuyen bajo la licencia Apache 2.0:

  • t5-small: 60 millones de parámetros
  • t5-base: 220 millones de parámetros
  • t5-large: 770 millones de parámetros. 3 GB de descarga.
  • t5-3b: 3,000 millones de parámetros. 11 GB de descarga.
  • t5-11b: 11,000 millones de parámetros. 45 GB de descarga.

Para obtener otros modelos de T5 disponibles, consulta el repositorio de Hugging Face.

Acerca de TorchServe

TorchServe es una herramienta flexible para entregar modelos de PyTorch. Proporciona compatibilidad lista para usar con todos los frameworks de aprendizaje profundo principales, incluidos PyTorch, TensorFlow y ONNX. TorchServe se puede usar para implementar modelos en producción o para prototipado y experimentación rápidos.

¿Qué sigue?