Exibir LLMs escalonáveis no GKE usando o TorchServe

Neste tutorial, mostramos como disponibilizar um machine learning (ML) do PyTorch pré-treinado em um cluster do GKE usando o Framework TorchServe para exibição escalonável. O modelo de ML usado neste tutorial gera previsões com base nas solicitações dos usuários. É possível usar as informações deste tutorial para ajudar você a implantar e disponibilizar seus próprios modelos em escala no GKE.

Sobre o aplicativo do tutorial

Ele é um pequeno aplicativo da Web em Python criado com o framework do Fast Dash. Use o aplicativo para enviar solicitações de previsão ao modelo T5. Ele captura entradas de texto do usuário e pares de idiomas e envia as informações ao modelo. O modelo converte o texto e retorna o resultado para o aplicativo, que mostra o resultado para o usuário. Para saber mais sobre a Fast Dash, consulte a documentação da Fast Dash.

Como funciona

Neste tutorial, vamos implantar as cargas de trabalho em um cluster do GKE Autopilot. O GKE gerencia totalmente os nós do Autopilot, o que reduz a sobrecarga administrativa na configuração, no escalonamento e nos upgrades de nós. Quando você implanta a carga de trabalho e o aplicativo de ML no Autopilot, o GKE escolhe o tipo e o tamanho corretos de máquina para executar as cargas de trabalho. Saiba mais na Visão geral do Autopilot.

Depois de implantar o modelo, você recebe um URL de previsão que pode ser usado pelo aplicativo para enviar solicitações de previsão ao modelo. Esse método dissocia o modelo do aplicativo, permitindo que o modelo seja escalonado independentemente do aplicativo da Web.

Objetivos

  • Preparar um modelo T5 pré-treinado do repositório Hugging Face para exibição empacotando-o como uma imagem de contêiner e enviando-o para o Artifact Registry
  • Implantar o modelo em um cluster do Autopilot
  • Implantar o aplicativo Fast Dash que se comunica com o modelo
  • Faça o escalonamento automático do modelo com base nas métricas do Prometheus

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

  1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. Install the Google Cloud CLI.

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

    gcloud init

  4. Crie ou selecione um projeto do Google Cloud.

    • Crie um projeto do Google Cloud:

      gcloud projects create PROJECT_ID

      Substitua PROJECT_ID por um nome para o projeto do Google Cloud que você está criando.

    • Selecione o projeto do Google Cloud que você criou:

      gcloud config set project PROJECT_ID

      Substitua PROJECT_ID pelo nome do projeto do Google Cloud.

  5. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  6. Ative as APIs Kubernetes Engine, Cloud Storage, Artifact Registry, and Cloud Build: 

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

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

    gcloud init

  9. Crie ou selecione um projeto do Google Cloud.

    • Crie um projeto do Google Cloud:

      gcloud projects create PROJECT_ID

      Substitua PROJECT_ID por um nome para o projeto do Google Cloud que você está criando.

    • Selecione o projeto do Google Cloud que você criou:

      gcloud config set project PROJECT_ID

      Substitua PROJECT_ID pelo nome do projeto do Google Cloud.

  10. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  11. Ative as APIs Kubernetes Engine, Cloud Storage, Artifact Registry, and Cloud Build: 

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

prepare o ambiente

Clone o repositório de exemplo e abra o diretório do tutorial:

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

Crie o cluster

Execute este comando:

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

Substitua:

  • RELEASE_CHANNEL: o canal de lançamento do cluster. Precisa ser rapid, regular ou stable. Escolha um canal que tenha a versão 1.28.3-gke.1203000 ou posterior do GKE para usar GPUs L4. Para conferir as versões disponíveis em um canal específico, consulte Visualizar as versões padrão e disponíveis para canais de lançamento.
  • CLUSTER_VERSION: a versão do GKE a ser usada. Precisa ser 1.28.3-gke.1203000 ou mais recente.

A operação leva alguns minutos para ser concluída.

Crie um repositório do Artifact Registry

  1. Crie um novo repositório padrão do Artifact Registry com o formato Docker na mesma região do cluster:

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

  2. Verifique o nome do repositório:

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

    O resultado será assim:

    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'

Empacotar o modelo

Nesta seção, você empacota o modelo e o framework de exibição em uma única imagem de contêiner usando o Cloud Build e envia a imagem resultante para o repositório do Artifact Registry.

  1. Revise o Dockerfile para a imagem do contêiner:

    # 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/

    Esse Dockerfile define o seguinte processo de compilação em várias etapas:

    1. Faça o download dos artefatos do modelo no repositório de rosto abraçado.
    2. Empacote o modelo usando a ferramenta Arquivo de exibição PyTorch. Isso cria um arquivo de modelo (.mar) que o servidor de inferência usa para carregar o modelo.
    3. Crie a imagem final com o PyTorch Serve.

  2. Crie e envie a imagem usando o 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

    O processo de implantação leva vários minutos para ser concluído. Se você usar um tamanho de modelo maior que t5-small, o processo de compilação poderá levar bastante mais tempo.

  3. Verifique se a imagem está no repositório:

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

    Substitua o PROJECT_ID pelo ID do projeto do Google Cloud.

    O resultado será assim:

    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

Implantar o modelo empacotado no GKE

Para implantar a imagem, modifique o manifesto do Kubernetes no repositório de exemplo para corresponder ao seu ambiente.

  1. Revise o manifesto da carga de trabalho de inferência:

    # 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. Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

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

    Isso garante que o caminho da imagem do contêiner na especificação da implantação corresponda ao caminho para a imagem do modelo T5 no Artifact Registry.

  3. Crie os recursos do Kubernetes:

    kubectl create -f kubernetes/serving-gpu.yaml

Para verificar se o modelo foi implantado, faça o seguinte:

  1. Confira o status da implantação e do serviço:

    kubectl get -f kubernetes/serving-gpu.yaml

    Aguarde até que a resposta mostre pods prontos, como no exemplo a seguir. Dependendo do tamanho da imagem, a primeira extração pode levar vários 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. Abra uma porta local para o serviço t5-inference:

    kubectl port-forward svc/t5-inference 8080

  3. Abra uma nova janela do terminal e envie uma solicitação de teste para o serviço:

    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"

    Se a solicitação de teste falhar e a conexão do pod for encerrada, verifique os registros:

    kubectl logs deployments/t5-inference

    Se a saída for semelhante a esta, o TorchServe não conseguiu instalar algumas dependências de modelo:

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

    Para resolver esse problema, reinicie a implantação:

    kubectl rollout restart deployment t5-inference

    Esse controlador cria um novo pod. Repita as etapas anteriores para abrir uma porta no novo pod.

Acesse o modelo implantado usando o aplicativo da Web

  1. Crie e envie o aplicativo da Web da Fast Dash como uma imagem de contêiner no Artifact Registry:

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

  2. Abra kubernetes/application.yaml em um editor de texto e substitua PROJECT_ID no campo image: pelo ID do projeto. Como alternativa, execute o seguinte comando:

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

  3. Crie os recursos do Kubernetes:

    kubectl create -f kubernetes/application.yaml

    A implantação e o serviço podem levar algum tempo para serem totalmente provisionados.

  4. Para verificar o status, execute o comando a seguir.

    kubectl get -f kubernetes/application.yaml

    Aguarde até que a saída mostre pods prontos, como no exemplo a seguir:

    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. O aplicativo da Web agora está em execução, embora não esteja exposto em um endereço IP externo. Para acessar o aplicativo da Web, abra uma porta local:

    kubectl port-forward service/fastdash 8050

  6. Em um navegador, abra a interface da Web:

    • Se você estiver usando um shell local, abra um navegador e acesse http://127.0.0.1:8050.
    • Se você estiver usando o Cloud Shell, clique em Visualização na Web e, em seguida, em Alterar porta. Especifique a porta 8050.

  7. Para enviar uma solicitação ao modelo T5, especifique os valores nos campos TEXT, TEXT e TEXT na interface da Web. e clique em TEXT. Para ver uma lista de idiomas disponíveis, consulte a documentação T5.

Ativar o escalonamento automático do modelo

Nesta seção, mostramos como ativar o escalonamento automático para o modelo com base em métricas do Google Cloud Managed Service para Prometheus fazendo o seguinte:

  1. Instalar o adaptador de métricas personalizadas do Stackdriver
  2. Aplicar configurações de PodMonitoring e HorizontalPodAutoscaling

O Google Cloud Managed Service para Prometheus é ativado por padrão nos clusters do Autopilot que executam a versão 1.25 e mais recentes.

Instalar o adaptador de métricas personalizadas do Stackdriver

Esse adaptador permite que o cluster use métricas do Prometheus para tomar decisões de escalonamento automático do Kubernetes.

  1. Implante o adaptador:

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

  2. Crie uma conta de serviço do IAM para o adaptador usar:

    gcloud iam service-accounts create monitoring-viewer

  3. Conceda à conta de serviço do IAM o papel monitoring.viewer no projeto e o papel 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]"

    Substitua o PROJECT_ID pelo ID do projeto do Google Cloud.

  4. Anote a ServiceAccount do Kubernetes do adaptador para permitir que ele represente a conta de serviço do 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. Reinicie a implantação do adaptador para propagar as alterações:

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

Aplicar configurações de PodMonitoring e HorizontalPodAutoscaling

O PodMonitoring é um recurso personalizado do Google Cloud Managed Service para Prometheus que permite a ingestão de métricas e a extração de destino em um namespace específico.

  1. Implante o recurso do PodMonitoring no mesmo namespace que a Implantação do TorchServe:

    kubectl apply -f kubernetes/pod-monitoring.yaml

  2. Consulte o manifesto 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"

    O HorizontalPodAutoscaler escalona a quantidade de pods do modelo T5 com base na duração cumulativa da fila de solicitações. O escalonamento automático é baseado na métrica ts_queue_latency_microseconds, que mostra a duração cumulativa da fila em microssegundos.

  3. Crie o HorizontalPodAutoscaler:

    kubectl apply -f kubernetes/hpa.yaml

Verificar o escalonamento automático usando um gerador de carga

Para testar a configuração de escalonamento automático, gere carga para o aplicativo de exibição. Neste tutorial, um gerador de carga do Locust é usado para enviar solicitações ao endpoint de previsão do modelo.

  1. Crie o gerador de carga:

    kubectl apply -f kubernetes/loadgenerator.yaml

    Aguarde até que os pods do gerador de carga fiquem prontos.

  2. Exponha a interface da Web do gerador de carga localmente:

    kubectl port-forward svc/loadgenerator 8080

    Se uma mensagem de erro for exibida, tente novamente quando o pod estiver em execução.

  3. Em um navegador, abra a interface da Web do gerador de carga.

    • Se você estiver usando um shell local, abra um navegador e acesse http://127.0.0.1:8080.
    • Se você estiver usando o Cloud Shell, clique em Visualização na Web e, em seguida, em Alterar porta. Digite a porta 8080.

  4. Clique na guia Gráficos para observar o desempenho ao longo do tempo.

  5. Abra uma nova janela do terminal e observe a contagem de réplicas dos seus escalonadores automáticos de pods horizontais:

    kubectl get hpa -w

    O número de réplicas aumenta conforme a carga aumenta. O escalonamento pode levar aproximadamente dez minutos. À medida que novas réplicas são iniciadas, o número de solicitações bem-sucedidas no gráfico do Locust aumenta.

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

Recomendações

  • Crie o modelo com a mesma versão da imagem base do Docker que você usará para disponibilização.
  • Se o modelo tiver dependências de pacote especiais ou se o tamanho das dependências for grande, crie uma versão personalizada da imagem base do Docker.
  • Observe a versão em árvore dos pacotes de dependência do modelo. Verifique se as dependências de pacote são compatíveis com as versões umas das outras. Por exemplo, o Panda versão 2.0.3 oferece suporte ao NumPy versão 1.20.3 e posterior.
  • Execute modelos com uso intensivo de GPU em nós de GPU e modelos com uso intensivo de CPU na CPU. Isso pode melhorar a estabilidade da disponibilização do modelo e garante o consumo eficiente dos recursos do nó.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Exclua o projeto

    Exclua um projeto do Google Cloud:

    gcloud projects delete PROJECT_ID

Excluir recursos individuais

  1. Exclua os recursos do 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. Exclua o cluster do GKE:

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

  3. Exclua a conta de serviço do IAM e as vinculações de política do 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. Exclua as imagens no Artifact Registry. Se quiser, exclua todo o repositório. Para mais instruções, consulte a documentação do Artifact Registry sobre Como excluir imagens.

Visão geral do componente

Nesta seção, descrevemos os componentes usados neste tutorial, como o modelo, o aplicativo da Web, o framework e o cluster.

Sobre o modelo T5

Neste tutorial, usamos um modelo T5 multilíngue pré-treinado. T5 é um transformador de texto para texto que converte texto de um idioma para outro. Em T5, entradas e saídas são sempre strings de texto, ao contrário dos modelos BERT que só podem gerar um rótulo de classe ou um período da entrada. O modelo T5 também pode ser usado para tarefas como resumo, perguntas e respostas ou classificação de texto. O modelo é treinado com uma grande quantidade de texto do Colossal Clean Crawled Corpus (C4) e do Wiki-DPR.

Para mais informações, consulte a documentação do modelo T5.

Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li e Peter J. Liu apresentou o modelo T5 em Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer, publicado no Journal of Pesquisa de machine learning.

O modelo T5 é compatível com vários tamanhos de modelo, com diferentes níveis de complexidade que se adaptam a casos de uso específicos. Neste tutorial, usamos o tamanho padrão, t5-small, mas também é possível escolher um tamanho diferente. Os tamanhos T5 a seguir são distribuídos de acordo com a licença Apache 2.0:

  • t5-small: 60 milhões de parâmetros.
  • t5-base: 220 milhões de parâmetros.
  • t5-large: 770 milhões de parâmetros. 3 GB de download.
  • t5-3b: três bilhões de parâmetros. 11 GB de download.
  • t5-11b (em inglês): 11 bilhões de parâmetros. 45 GB de download.

Para outros modelos T5 disponíveis, consulte o repositório Hugging Face (em inglês).

Sobre o TorchServe

O TorchServe é uma ferramenta flexível para disponibilizar modelos PyTorch. Ele oferece suporte imediato para todos os principais frameworks de aprendizado profundo, incluindo PyTorch, TensorFlow e ONNX. O TorchServe pode ser usado para implantar modelos em produção ou para prototipagem e experimentação rápidas.

A seguir