Gestisci LLM scalabili su GKE utilizzando TorchServe

Questo tutorial mostra come pubblicare un modello di machine learning (ML) PyTorch preaddestrato su un cluster GKE utilizzando il framework TorchServe per la pubblicazione scalabile. Il modello ML utilizzato in questo tutorial genera previsioni in base alle richieste degli utenti. Puoi utilizzare le informazioni di questo tutorial per eseguire il deployment e i tuoi modelli su larga scala su GKE.

Informazioni sulla richiesta di tutorial

L'applicazione è una piccola applicazione web Python creata utilizzando Framework Fast Dash. Puoi utilizzare l'applicazione per inviare richieste di previsione al modello T5. Questa applicazione acquisisce gli input di testo dell'utente e le coppie di lingue e invia le informazioni al modello. Il modello traduce il testo e restituisce il risultato. all'applicazione, che mostra il risultato all'utente. Per ulteriori informazioni su Fast Dash, vedi la documentazione di Fast Dash.

Come funziona

Questo tutorial esegue il deployment dei carichi di lavoro su un cluster GKE Autopilot in un cluster Kubernetes. GKE gestisce completamente i nodi Autopilot, riduce i costi amministrativi per la configurazione, la scalabilità e gli upgrade dei nodi. Quando esegui il deployment del carico di lavoro e dell'applicazione ML su Autopilot, GKE sceglie il tipo di macchina sottostante e le dimensioni corrette da eseguire per gestire i carichi di lavoro. Per ulteriori informazioni, consulta la panoramica di Autopilot.

Dopo aver eseguito il deployment del modello, ottieni un URL di previsione che l'applicazione può per inviare richieste di previsione al modello. Questo metodo disaccoppia il modello dall'applicazione, consentendo di scalare il modello indipendentemente dall'applicazione web.

Obiettivi

  • Prepara un modello T5 preaddestrato dal repository Hugging Face per la pubblicazione, impacchettandolo come immagine container e spingendolo in Artifact Registry
  • Esegui il deployment del modello in un cluster Autopilot
  • Esegui il deployment dell'applicazione Fast Dash che comunica con il modello
  • Scalabilità automatica del modello in base alle metriche di Prometheus

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

  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

prepara l'ambiente

Clona il repository di esempio e apri la directory del tutorial:

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

Crea il cluster

Esegui questo comando:

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

Sostituisci quanto segue:

  • RELEASE_CHANNEL: il canale di rilascio per il tuo cluster. Deve essere rapid, regular o stable. Scegli un canale con GKE 1.28.3-gke.1203000 o versioni successive per utilizzare le GPU L4. Per visualizzare le versioni disponibili in un canale specifico, consulta Visualizzare le versioni predefinite e disponibili per i canali di rilascio.
  • CLUSTER_VERSION: la versione di GKE da utilizzare. Deve essere 1.28.3-gke.1203000 o successiva.

Il completamento di questa operazione richiede diversi minuti.

Crea un repository Artifact Registry

  1. Crea un nuovo repository standard Artifact Registry con il formato Docker nella stessa regione del tuo cluster:

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

  2. Verifica il nome del repository:

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

    L'output è simile al seguente:

    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'

Impacchetta il modello

In questa sezione, pacchettizzerai il modello e il framework di pubblicazione in un'unica dell'immagine container utilizzando Cloud Build ed esegui il push dell'immagine risultante repository Artifact Registry.

  1. Esamina il Dockerfile dell'immagine container:

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

    Questo Dockerfile definisce la seguente procedura di compilazione in più fasi:

    1. Scarica gli artefatti del modello dal repository di Hugging Face.
    2. Impacchetta il modello utilizzando lo strumento PyTorch Serving Archive. Questo crea un file di archivio dei modelli (.mar) che il server di inferenza per caricare il modello.
    3. Crea l'immagine finale con PyTorch Serve.

  2. Crea ed esegui il push dell'immagine utilizzando 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

    Il processo di compilazione richiede diversi minuti. Se utilizzi un modello più grande maggiore di t5-small, il processo di compilazione potrebbe richiedere molto di più nel tempo.

  3. Verifica che l'immagine sia nel repository:

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

    Sostituisci PROJECT_ID con il tuo Google Cloud dell'ID progetto.

    L'output è simile al seguente:

    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

esegui il deployment del modello in pacchetto su GKE

Per eseguire il deployment dell'immagine, modifica il manifest di Kubernetes nel repository di esempio in modo che corrisponda al tuo ambiente.

  1. Esamina il manifest per il carico di lavoro di inferenza:

    # 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. Sostituisci PROJECT_ID con il tuo Google Cloud ID progetto:

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

    In questo modo, il percorso dell'immagine container nella specifica di deployment corrisponde al percorso dell'immagine del modello T5 in Artifact Registry.

  3. Crea le risorse Kubernetes:

    kubectl create -f kubernetes/serving-gpu.yaml

Per verificare che il deployment del modello sia andato a buon fine:

  1. Visualizza lo stato del deployment e del servizio:

    kubectl get -f kubernetes/serving-gpu.yaml

    Attendi finché l'output non mostra pod pronti, come in questo caso. A seconda delle dimensioni dell'immagine, il primo recupero dell'immagine potrebbe richiedere diversi minuti.

    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. Apri una porta locale per il servizio t5-inference:

    kubectl port-forward svc/t5-inference 8080

  3. Apri una nuova finestra del terminale e invia una richiesta di test al servizio:

    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 la richiesta di test non va a buon fine e la connessione del pod si chiude, controlla i log:

    kubectl logs deployments/t5-inference

    Se l'output è simile al seguente, l'installazione di TorchServe non è riuscita alcune dipendenze del modello:

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

    Per risolvere il problema, riavvia il deployment:

    kubectl rollout restart deployment t5-inference

    Il controller Deployment crea un nuovo pod. Ripeti i passaggi precedenti per aprire una porta sul nuovo pod.

Accedi al modello di cui è stato eseguito il deployment utilizzando l'applicazione web

  1. Crea ed esegui il push dell'applicazione web Fast Dash come immagine container in Artifact Registry:

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

  2. Apri kubernetes/application.yaml in un editor di testo e sostituisci PROJECT_ID nel campo image: con il tuo dell'ID progetto. In alternativa, esegui questo comando:

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

  3. Crea le risorse Kubernetes:

    kubectl create -f kubernetes/application.yaml

    Il provisioning completo del deployment e del servizio potrebbe richiedere del tempo.

  4. Per controllare lo stato, esegui il seguente comando:

    kubectl get -f kubernetes/application.yaml

    Attendi che l'output mostri i pod pronti, come nel seguente esempio:

    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. L'applicazione web è ora in esecuzione, anche se non è esposta su un indirizzo IP esterno. Per accedere all'applicazione web, apri una porta locale:

    kubectl port-forward service/fastdash 8050

  6. Apri l'interfaccia web in un browser:

    • Se utilizzi una shell locale, apri un browser e vai all'indirizzo http://127.0.0.1:8050.
    • Se utilizzi Cloud Shell, fai clic su Anteprima web, quindi fai clic su Cambia porta. Specifica la porta 8050.

  7. Per inviare una richiesta al modello T5, specifica i valori in TEXT, FROM LANGUAGE e TO LANGUAGE nell'interfaccia web e fai clic su Invia. Per un elenco delle lingue disponibili, vedi Documentazione T5.

Abilita la scalabilità automatica per il modello

Questa sezione mostra come attivare la scalabilità automatica per il modello in base alle metriche di Google Cloud Managed Service per Prometheus svolgendo i seguenti passaggi:

  1. Installa l'adattatore Stackdriver delle metriche personalizzate
  2. Applica le configurazioni di PodMonitoring e HorizontalPodAutoscaling

Google Cloud Managed Service per Prometheus è abilitato per impostazione predefinita in Autopilot con la versione 1.25 e successive.

Installa l'adattatore Stackdriver per metriche personalizzate

Questo adattatore consente al cluster di utilizzare le metriche di Prometheus per prendere decisioni di scalabilità automatica di Kubernetes.

  1. Distribuisci l'adattatore:

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

  2. Crea un account di servizio IAM da utilizzare per l'adattatore:

    gcloud iam service-accounts create monitoring-viewer

  3. Concedi all'account di servizio IAM il ruolo monitoring.viewer in il progetto e il ruolo 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]"

    Sostituisci PROJECT_ID con il tuo ID progetto Google Cloud.

  4. Annota l'account di servizio Kubernetes dell'adattatore per consentirne l'identità l'account di servizio 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. Riavvia l'adattatore per propagare le modifiche:

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

Applica le configurazioni PodMonitoring e HorizontalPodAutoscalaling

PodMonitoring è una risorsa personalizzata di Google Cloud Managed Service per Prometheus che consente l'importazione delle metriche e lo scraping dei target in uno spazio dei nomi specifico.

  1. Esegui il deployment della risorsa PodMonitoring nello stesso spazio dei nomi di TorchServe Deployment:

    kubectl apply -f kubernetes/pod-monitoring.yaml

  2. Esamina il manifest di 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"

    HorizontalPodAutoscaler scala la quantità di pod del modello T5 in base alla durata cumulativa della coda di richieste. La scalabilità automatica si basa sulla metrica ts_queue_latency_microseconds, che mostra la durata cumulativa della coda in microsecondi.

  3. Crea HorizontalPodAutoscaler:

    kubectl apply -f kubernetes/hpa.yaml

Verificare la scalabilità automatica utilizzando un generatore di carico

Per testare la configurazione della scalabilità automatica, genera il carico per la pubblicazione un'applicazione. Questo tutorial utilizza un generatore di carico di Locust per inviare richieste ai endpoint di previsione per il modello.

  1. Crea il generatore di carico:

    kubectl apply -f kubernetes/loadgenerator.yaml

    Attendi che i pod del generatore di carico siano pronti.

  2. Esponi localmente l'interfaccia web del generatore di carico:

    kubectl port-forward svc/loadgenerator 8080

    Se vedi un messaggio di errore, riprova mentre il pod è in esecuzione.

  3. In un browser, apri l'interfaccia web del generatore di carico:

    • Se utilizzi una shell locale, apri un browser e vai su http://127.0.0.1:8080.
    • Se utilizzi Cloud Shell, fai clic su Anteprima web, quindi Fai clic su Cambia porta. Inserisci la porta 8080.

  4. Fai clic sulla scheda Grafici per osservare il rendimento nel tempo.

  5. Apri una nuova finestra del terminale e osserva il numero di repliche del tuo Horizontal Pod Autoscaler:

    kubectl get hpa -w

    Il numero di repliche aumenta con l'aumento del carico. L'operazione di scalabilità potrebbe richiedere circa dieci minuti. All'avvio delle nuove repliche, il numero delle richieste andate a buon fine nel grafico a locusta aumenta.

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

Consigli

  • Crea il tuo modello con la stessa versione dell'immagine Docker di base che utilizzerai per la pubblicazione.
  • Se il tuo modello ha dipendenze di pacchetti speciali o se le dimensioni delle dipendenze sono elevate, crea una versione personalizzata dell'immagine Docker di base.
  • Osserva la versione ad albero dei pacchetti di dipendenze del modello. Assicurati che le dipendenze dei pacchetti si supportano reciprocamente e versioni successive. Ad esempio, versione Panda 2.0.3 supporta NumPy versione 1.20.3 e successive.
  • Esegui modelli che richiedono l'uso intensivo di GPU su nodi GPU e modelli che richiedono l'uso intensivo di CPU su CPU. Questo migliorare la stabilità della pubblicazione del modello e assicurarti di per utilizzare in modo efficiente le risorse dei nodi.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

    Delete a Google Cloud project:

    gcloud projects delete PROJECT_ID

Elimina singole risorse

  1. Elimina le risorse 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. Elimina il cluster GKE:

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

  3. Elimina l'account di servizio IAM e le associazioni di criteri 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. Elimina le immagini in Artifact Registry. (Facoltativo) Elimina l'intero repository. Per le istruzioni, consulta la documentazione di Artifact Registry Eliminazione delle immagini.

Panoramica dei componenti

Questa sezione descrive i componenti utilizzati in questo tutorial, come modello, l'applicazione web, il framework e il cluster.

Informazioni sul modello T5

Questo tutorial utilizza un modello T5 multilingue preaddestrato. T5 è un trasformatore text-to-text che converte il testo da una lingua all'altra. In T5, gli input e sono sempre stringhe di testo, a differenza dei modelli di stile BERT che possono restituisce un'etichetta di classe o un intervallo dell'input. Il modello T5 può essere utilizzato anche per attività come il riassunto, le domande e risposte o la classificazione del testo. Il modello viene addestrato su una grande quantità di testo Colossal Clean Scaned Corpus (C4) e Wiki-DPR.

Per ulteriori informazioni, consulta la documentazione del modello T5.

Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li e Peter J. Liu ha presentato il modello T5 in Esplora i limiti del Transfer Learning con un convertitore da testo a testo unificato, pubblicato sul Journal of Machine Learning Research.

Il modello T5 supporta diverse dimensioni di modelli, con diversi livelli di complessità che rispondono a casi d'uso specifici. Questo tutorial utilizza le dimensioni predefinite, t5-small, ma puoi anche sceglierne una diversa. Le seguenti dimensioni T5 sono distribuite con la licenza Apache 2.0:

  • t5-small: 60 milioni di parametri
  • t5-base: 220 milioni di parametri
  • t5-large: e 770 milioni di parametri. Download di 3 GB.
  • t5-3b: tre miliardi di parametri. Download di 11 GB.
  • t5-11b: 11 miliardi di parametri. 45 GB per il download.

Per altri modelli T5 disponibili, consulta il repository Hugging Face.

Informazioni su TorchServe

TorchServe è uno strumento flessibile per fornire i modelli PyTorch. Fornisce il supporto out of the box per tutti i principali framework di deep learning, tra cui PyTorch, TensorFlow e ONNX. TorchServe può essere usato per eseguire il deployment dei modelli in produzione oppure per la prototipazione e la sperimentazione rapide.

Passaggi successivi