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. 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 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

    Delete a Google Cloud project:

    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