Gestisci un LLM utilizzando TPU su GKE con JetStream e PyTorch

Questa guida mostra come pubblicare un modello linguistico di grandi dimensioni (LLM) (LLM) utilizzando Tensor Processing Unit (TPU) su Google Kubernetes Engine (GKE) con Da JetStream a PyTorch. In questa guida, scarichi i pesi del modello in Cloud Storage ed esegui il loro deployment su un cluster GKE Autopilot o Standard utilizzando un contenitore che esegue JetStream.

Se hai bisogno di scalabilità, resilienza e costi contenuti offerti dalle funzionalità di Kubernetes durante il deployment JetStream, questa guida è un buon punto di partenza.

Questa guida è rivolta ai clienti di IA generativa che utilizzano PyTorch, nuovi per gli utenti esistenti di GKE, ML Engineer, MLOps (DevOps) engineer amministratori di piattaforma interessati all'utilizzo di container di orchestrazione per la distribuzione degli LLM.

Sfondo

Se pubblichi un modello LLM utilizzando TPU su GKE con JetStream, puoi creare una soluzione di pubblicazione solida e pronta per la produzione con tutti i vantaggi di Kubernetes gestito, tra cui economicità, scalabilità e maggiore disponibilità. Questa sezione descrive le tecnologie chiave usate in questo tutorial.

Informazioni sulle TPU

Le TPU sono circuiti integrati per applicazioni specifiche (ASIC) sviluppati da Google e utilizzati per accelerare i modelli di machine learning e IA creati utilizzando framework come TensorFlow, PyTorch e JAX.

Prima di utilizzare le TPU in GKE, ti consigliamo di completare il seguente percorso di apprendimento:

  1. Scopri di più sulla disponibilità attuale della versione di TPU con l'architettura di sistema Cloud TPU.
  2. Scopri di più sulle TPU in GKE.

Questo tutorial illustra la gestione di vari modelli LLM. GKE esegue il deployment del modello su nodi TPUv5e a host singolo con topologie TPU configurate in base ai requisiti del modello per la pubblicazione di prompt con bassa latenza.

Informazioni su JetStream

JetStream è un framework per il servizio di inferenza open source sviluppato da Google. JetStream consente l'inferenza ad alte prestazioni, elevata velocità in uscita e ottimizzata per la memoria su TPU e GPU. JetStream offre ottimizzazioni avanzate delle prestazioni, tra cui batch continui, Ottimizzazioni della cache dei valori chiave e tecniche di quantizzazione per facilitare i modelli LLM e deployment continuo. JetStream consente la pubblicazione di TPU PyTorch/XLA e JAX per ottenere prestazioni ottimali.

Raggruppamento continuo

Il batch continuo è una tecnica che raggruppa dinamicamente l'inferenza in entrata richieste in batch, riducendo la latenza e aumentando la velocità effettiva.

Quantizzazione della cache di valori KV

La quantizzazione della cache KV prevede la compressione della cache chiave-valore utilizzata nei meccanismi di attenzione, riducendo i requisiti di memoria.

Quantizzazione dei pesi Int8

La quantizzazione dei pesi Int8 riduce la precisione dei pesi del modello da valori in virgola mobile a 32 bit a interi a 8 bit, con un conseguente calcolo più rapido e un utilizzo ridotto della memoria.

Per scoprire di più su queste ottimizzazioni, consulta i repository dei progetti JetStream PyTorch e JetStream MaxText.

Informazioni su PyTorch

PyTorch è un framework di machine learning open source sviluppato da Meta e ora fa parte della Linux Foundation. PyTorch offre funzionalità di alto livello come il calcolo di tensori e le reti neurali profonde.

Obiettivi

  1. Prepara un cluster GKE Autopilot o Standard con la topologia TPU consigliata in base alle caratteristiche del modello.
  2. Esegui il deployment dei componenti JetStream su GKE.
  3. Recupera e pubblica il modello.
  4. Pubblica e interagisci con il modello pubblicato.

Architettura

Questa sezione descrive l'architettura di GKE utilizzata in questo tutorial. L'architettura include un motore GKE Autopilot Cluster standard che esegue il provisioning di TPU e ospita componenti JetStream per eseguire il deployment e distribuire i modelli.

Il seguente diagramma mostra i componenti di questa architettura:

Architettura del cluster GKE con pool di nodi TPU a host singolo che contengono i componenti HTTP JetStream-PyTorch e JetStream.

Questa architettura include i seguenti componenti:

  • Un cluster GKE Autopilot o Standard a livello di regione.
  • Due pool di nodi di sezione TPU con host singolo che ospitano il deployment JetStream.
  • Il componente Service distribuisce il traffico in entrata a tutte le repliche JetStream HTTP.
  • JetStream HTTP è un server HTTP che accetta le richieste come wrapper per il formato richiesto da JetStream e le invia al client GRPC di JetStream.
  • JetStream-PyTorch è un server JetStream che esegue l'inferenza con batch continui.

Prima di iniziare

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

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

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

  • Enable the required API.

    Enable the API

    •

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

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

  • Enable the required API.

    Enable the API

    •

  • Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin

    Check for the roles

    1. In the Google Cloud console, go to the IAM page.

      Go to IAM
    2. Select the project.

    3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

    4. For all rows that specify or include you, check the Role colunn to see whether the list of roles includes the required roles.

    Grant the roles

    1. In the Google Cloud console, go to the IAM page.

      Vai a IAM
    2. Seleziona il progetto.
    3. Fai clic su Concedi accesso.

    4. Nel campo Nuove entità, inserisci il tuo identificatore utente. In genere si tratta dell'indirizzo email di un Account Google.

    5. Nell'elenco Seleziona un ruolo, seleziona un ruolo.
    6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo aggiuntivo.
    7. Fai clic su Salva.
  • Assicurati di avere una quota sufficiente per otto chip TPU v5e PodSlice Lite. In questo tutorial vengono utilizzate le istanze on demand.
  • Crea un token Affetto, se non ne hai già uno.

Ottieni l'accesso al modello

Accedi a vari modelli su Hugging Face per il deployment in GKE

Gemma 7B-it

Per ottenere l'accesso al modello Gemma per il deployment in GKE, devi prima firmare il contratto di consenso per la licenza.

  1. Accedi alla pagina di consenso del modello Gemma su Hugging Face
  2. Se non l'hai ancora fatto, accedi a Hugging Face.
  3. Leggi e accetta i Termini e condizioni del modello.

Lama 3 8B

Per ottenere l'accesso al modello Llama 3 per il deployment su GKE, devi prima firmare il contratto di consenso per le licenze.

  1. Accedi alla pagina relativa al consenso del modello Lama 3 su Hugging Face
  2. Se non l'hai ancora fatto, accedi a Hugging Face.
  3. Leggi e accetta i Termini e condizioni del modello.

prepara l'ambiente

In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Cloud Shell include il software di cui avrai bisogno per questo tutorial, tra cui kubectl e gcloud CLI.

Per configurare l'ambiente con Cloud Shell, segui questi passaggi:

  1. Nella console Google Cloud, avvia una sessione di Cloud Shell facendo clic su Icona di attivazione di Cloud Shell Attiva Cloud Shell nella console Google Cloud. Viene avviata una sessione nella riquadro inferiore della console Google Cloud.

  2. Imposta le variabili di ambiente predefinite:

    gcloud config set project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export CLUSTER_NAME=CLUSTER_NAME
export BUCKET_NAME=BUCKET_NAME
export REGION=REGION
export LOCATION=LOCATION
export CLUSTER_VERSION=CLUSTER_VERSION

    Sostituisci i seguenti valori:

    • PROJECT_ID: il tuo ID progetto Google Cloud.
    • CLUSTER_NAME: il nome del tuo cluster GKE.
    • BUCKET_NAME: il nome del bucket Cloud Storage. Non è necessario specificare il prefisso gs://.
    • REGION: la regione in cui GKE cluster, il bucket Cloud Storage e i nodi TPU. La regione contiene zone in cui sono disponibili tipi di macchine TPU v5e (ad esempio, us-west1, us-west4, us-central1, us-east1, us-east5 o europe-west4). Per i cluster Autopilot, assicurati di disporre di risorse di zona TPU v5e sufficienti per la tua regione.
    • (Solo cluster standard) LOCATION: la zona in cui sono disponibili le risorse TPU (ad esempio us-west4-a). Per i cluster Autopilot, non è necessario specificare la zona, ma solo la regione.
    • CLUSTER_VERSION: la versione di GKE, che deve supportare il tipo di macchina che vuoi utilizzare. Tieni presente che la versione GKE predefinita potrebbe non avere disponibilità per la TPU di destinazione. Per un elenco delle versioni minime di GKE disponibili per tipo di macchina TPU, consulta Disponibilità TPU in GKE.

Creazione e configurazione delle risorse Google Cloud

Segui queste istruzioni per creare le risorse richieste.

Crea un cluster GKE

Puoi eseguire Gemma su TPU in un cluster GKE Autopilot o Standard. Ti consigliamo di utilizzare un cluster Autopilot per un'esperienza Kubernetes completamente gestita. Per scegliere la modalità operativa GKE più adatta ai tuoi carichi di lavoro, vedi Scegliere una modalità operativa di GKE.

Autopilot

Crea un cluster GKE Autopilot:

gcloud container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --region=REGION \
    --cluster-version=CLUSTER_VERSION

Standard

  1. Crea un cluster GKE Standard a livello di regione che utilizza la Federazione delle identità per i carichi di lavoro per GKE:

    gcloud container clusters create CLUSTER_NAME \
    --enable-ip-alias \
    --machine-type=e2-standard-4 \
    --num-nodes=2 \
    --cluster-version=CLUSTER_VERSION \
    --workload-pool=PROJECT_ID.svc.id.goog \
    --location=REGION

    La creazione del cluster potrebbe richiedere diversi minuti.

  2. Crea un pool di nodi TPU v5e con una topologia 2x4 e due nodi:

    gcloud container node-pools create tpu-nodepool \
  --cluster=CLUSTER_NAME \
  --machine-type=ct5lp-hightpu-8t \
  --project=PROJECT_ID \
  --num-nodes=2 \
  --region=REGION \
  --node-locations=LOCATION

Crea un bucket Cloud Storage

Crea un bucket Cloud Storage per archiviare il checkpoint convertito:

gcloud storage buckets create gs://BUCKET_NAME --location=REGION

Genera il token dell'interfaccia a riga di comando Hugging Face in Cloud Shell

Genera un nuovo token Abbracciamento se non ne hai già uno:

  1. Fai clic su Il tuo profilo > Impostazioni > Token di accesso.
  2. Fai clic su Nuovo token.
  3. Specifica un nome a tua scelta e un ruolo di almeno Read.
  4. Fai clic su Generate a token (Genera un token).
  5. Modifica le autorizzazioni al token di accesso per avere accesso in lettura al repository Hugging Face del tuo modello.
  6. Copia il token generato negli appunti.

Crea un secret di Kubernetes per le credenziali di Hugging Face

In Cloud Shell, segui questi passaggi:

  1. Configura kubectl in modo che comunichi con il tuo cluster:

    gcloud container clusters get-credentials CLUSTER_NAME --location=REGION

  2. Crea un secret per archiviare le credenziali di Hugging Face:

    kubectl create secret generic huggingface-secret \
    --from-literal=HUGGINGFACE_TOKEN=HUGGINGFACE_TOKEN

    Sostituisci HUGGINGFACE_TOKEN con il tuo token Hugging Face.

Configura l'accesso ai carichi di lavoro utilizzando la federazione delle identità per i carichi di lavoro per GKE

Assegnare un Account di servizio Kubernetes all'applicazione e configurare l'Account di servizio Kubernetes in modo che agisca come Account di servizio IAM.

  1. Crea un account di servizio IAM per la tua applicazione:

    gcloud iam service-accounts create wi-jetstream

  2. Aggiungi un'associazione dei criteri IAM per il tuo account di servizio IAM a per gestire Cloud Storage:

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:wi-jetstream@PROJECT_ID.iam.gserviceaccount.com" \
    --role roles/storage.objectUser

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:wi-jetstream@PROJECT_ID.iam.gserviceaccount.com" \
    --role roles/storage.insightsCollectorService

  3. Consenti all'account di servizio Kubernetes di simulare l'account di servizio IAM aggiungendo un'associazione dei criteri IAM tra i due account di servizio. Questa associazione consente all'account di servizio Kubernetes di agire come account di servizio IAM:

    gcloud iam service-accounts add-iam-policy-binding wi-jetstream@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[default/default]"

  4. Annota l'account di servizio Kubernetes con l'indirizzo email dell'account di servizio IAM:

    kubectl annotate serviceaccount default \
    iam.gke.io/gcp-service-account=wi-jetstream@PROJECT_ID.iam.gserviceaccount.com

Converti i checkpoint del modello

In questa sezione crei un job per:

  1. Scarica il checkpoint di base da Hugging Face nella directory locale.
  2. Converti il checkpoint in un checkpoint compatibile con JetStream-Pytorch.
  3. Carica il checkpoint in un bucket Cloud Storage.

Esegui il deployment del job di conversione del checkpoint del modello

Gemma 7B-it

Scarica e converti i file di checkpoint del modello Gemma 7B:

  1. Salva il seguente manifest come job-checkpoint-converter.yaml:

    apiVersion: batch/v1
kind: Job
metadata:
  name: checkpoint-converter
spec:
  ttlSecondsAfterFinished: 30
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: inference-checkpoint
        image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.3
        args:
        - -s=jetstream-pytorch
        - -m=google/gemma-7b-it-pytorch
        - -o=gs://BUCKET_NAME/pytorch/gemma-7b-it/final/bf16/
        - -n=gemma
        - -q=False
        - -h=True
        volumeMounts:
        - mountPath: "/huggingface/"
          name: huggingface-credentials
          readOnly: true
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      volumes:
      - name: huggingface-credentials
        secret:
          defaultMode: 0400
          secretName: huggingface-secret

Llama 3 8B

Scarica e converti i file di checkpoint del modello Llama 3 8B:

  1. Salva il seguente manifest come job-checkpoint-converter.yaml:

    apiVersion: batch/v1
kind: Job
metadata:
  name: checkpoint-converter
spec:
  ttlSecondsAfterFinished: 30
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: inference-checkpoint
        image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.3
        args:
        - -s=jetstream-pytorch
        - -m=meta-llama/Meta-Llama-3-8B
        - -o=gs://BUCKET_NAME/pytorch/llama-3-8b/final/bf16/
        - -n=llama-3
        - -q=False
        - -h=True
        volumeMounts:
        - mountPath: "/huggingface/"
          name: huggingface-credentials
          readOnly: true
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      volumes:
      - name: huggingface-credentials
        secret:
          defaultMode: 0400
          secretName: huggingface-secret

  1. Sostituisci BUCKET_NAME con il tuo bucket Google Storage creato in precedenza:

    sed -i "s|BUCKET_NAME|BUCKET_NAME|g" job-checkpoint-converter.yaml

  2. Applica il manifest:

    kubectl apply -f job-checkpoint-converter.yaml

  3. Attendi l'avvio dell'esecuzione del job da parte del pod che pianifica il job:

    kubectl get pod -w

    L'output sarà simile al seguente. L'operazione potrebbe richiedere alcuni minuti:

    NAME                        READY   STATUS              RESTARTS   AGE
checkpoint-converter-abcd   0/1     ContainerCreating   0          28s
checkpoint-converter-abcd   1/1     Running             0          51s

    Per i cluster Autopilot, il provisioning delle risorse TPU richieste potrebbe richiedere alcuni minuti.

  4. Verifica che il job sia stato completato visualizzando i relativi log:

    kubectl logs -f jobs/checkpoint-converter

    Una volta completato il job, l'output è simile al seguente:

    Completed uploading converted checkpoint from local path /pt-ckpt/ to GSBucket gs://BUCKET_NAME/pytorch/<model_name>/final/bf16/"

Esegui il deployment di JetStream

Esegui il deployment del contenitore JetStream per pubblicare il modello:

Salva il seguente manifest come jetstream-pytorch-deployment.yaml:

Gemma 7B-it

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jetstream-pytorch-server
spec:
  replicas: 2
  selector:
    matchLabels:
      app: jetstream-pytorch-server
  template:
    metadata:
      labels:
        app: jetstream-pytorch-server
      annotations:
        gke-gcsfuse/volumes: "true"
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      containers:
      - name: jetstream-pytorch-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-pytorch-server:v0.2.3
        args:
        - --size=7b
        - --model_name=gemma
        - --batch_size=32
        - --max_cache_length=2048
        - --quantize_weights=False
        - --quantize_kv_cache=False
        - --tokenizer_path=/models/pytorch/gemma-7b-it/final/bf16/tokenizer.model
        - --checkpoint_path=/models/pytorch/gemma-7b-it/final/bf16/model.safetensors
        ports:
        - containerPort: 9000
        volumeMounts:
        - name: gcs-fuse-checkpoint
          mountPath: /models
          readOnly: true
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      - name: jetstream-http
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.2
        ports:
        - containerPort: 8000
      volumes:
      - name: gcs-fuse-checkpoint
        csi:
          driver: gcsfuse.csi.storage.gke.io
          readOnly: true
          volumeAttributes:
            bucketName: BUCKET_NAME
            mountOptions: "implicit-dirs"
---
apiVersion: v1
kind: Service
metadata:
  name: jetstream-svc
spec:
  selector:
    app: jetstream-pytorch-server
  ports:
  - protocol: TCP
    name: jetstream-http
    port: 8000
    targetPort: 8000

Lama 3 8B

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jetstream-pytorch-server
spec:
  replicas: 2
  selector:
    matchLabels:
      app: jetstream-pytorch-server
  template:
    metadata:
      labels:
        app: jetstream-pytorch-server
      annotations:
        gke-gcsfuse/volumes: "true"
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      containers:
      - name: jetstream-pytorch-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-pytorch-server:v0.2.3
        args:
        - --size=8b
        - --model_name=llama-3
        - --batch_size=32
        - --max_cache_length=2048
        - --quantize_weights=False
        - --quantize_kv_cache=False
        - --tokenizer_path=/models/pytorch/llama-3-8b/final/bf16/tokenizer.model
        - --checkpoint_path=/models/pytorch/llama-3-8b/final/bf16/model.safetensors
        ports:
        - containerPort: 9000
        volumeMounts:
        - name: gcs-fuse-checkpoint
          mountPath: /models
          readOnly: true
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      - name: jetstream-http
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.2
        ports:
        - containerPort: 8000
      volumes:
      - name: gcs-fuse-checkpoint
        csi:
          driver: gcsfuse.csi.storage.gke.io
          readOnly: true
          volumeAttributes:
            bucketName: BUCKET_NAME
            mountOptions: "implicit-dirs"
---
apiVersion: v1
kind: Service
metadata:
  name: jetstream-svc
spec:
  selector:
    app: jetstream-pytorch-server
  ports:
  - protocol: TCP
    name: jetstream-http
    port: 8000
    targetPort: 8000

Il file manifest imposta le seguenti proprietà chiave:

  • size: le dimensioni del modello.
  • model_name: il nome del modello (gemma, llama-3).
  • batch_size: la dimensione del batch di decodifica per dispositivo, dove un chip TPU equivale a un dispositivo.
  • max_cache_length: lunghezza massima della cache kv.
  • quantize_weights: indica se il checkpoint è quantizzato.
  • quantize_kv_cache: indica se la cache KV è quantizzata.
  • tokenizer_path: il percorso del file del tokenizzatore del modello.
  • checkpoint_path: il percorso del checkpoint.

  1. Sostituisci BUCKET_NAME con il tuo bucket Google Storage creato in precedenza:

    sed -i "s|BUCKET_NAME|BUCKET_NAME|g" jetstream-pytorch-deployment.yaml

  2. Applica il manifest:

    kubectl apply -f jetstream-pytorch-deployment.yaml

  3. Verifica il deployment:

    kubectl get deployment

    L'output è simile al seguente:

    NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
jetstream-pytorch-server          2/2     2            2           ##s

    Per i cluster Autopilot, potrebbero essere necessari alcuni minuti per il provisioning delle risorse TPU richieste.

  4. Visualizza i log del server HTTP per verificare che il modello sia stato caricato e compilato. Il server potrebbe impiegare qualche minuto per completare questa operazione.

    kubectl logs deploy/jetstream-pytorch-server -f -c jetstream-http

    L'output è simile al seguente:

    kubectl logs deploy/jetstream-pytorch-server -f -c jetstream-http

INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

  5. Visualizza i log del server JetStream-PyTorch e verifica che la compilazione sia stata completata:

    kubectl logs deploy/jetstream-pytorch-server -f -c jetstream-pytorch-server

    L'output è simile al seguente:

    Started jetstream_server....
2024-04-12 04:33:37,128 - root - INFO - ---------Generate params 0 loaded.---------

Pubblica il modello

In questa sezione devi interagire con il modello.

Configura il port forwarding

Puoi accedere al deployment JetStream tramite il servizio ClusterIP che creato nel passaggio precedente. I servizi ClusterIP sono raggiungibili solo dall'interno del cluster. Pertanto, per accedere al servizio dall'esterno del cluster, completa i seguenti passaggi:

Per stabilire una sessione di inoltro di porte, esegui il seguente comando:

kubectl port-forward svc/jetstream-svc 8000:8000

Interagire con il modello utilizzando curl

  1. Verifica di poter accedere al server HTTP JetStream aprendo un nuovo terminale ed eseguendo il seguente comando:

    curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8000/generate \
--data \
'{
    "prompt": "What are the top 5 programming languages",
    "max_tokens": 200
}'

    Il completamento della richiesta iniziale può richiedere diversi secondi a causa del riscaldamento del modello. L'output è simile al seguente:

    {
    "response": " for data science in 2023?\n\n**1. Python:**\n- Widely used for data science due to its readability, extensive libraries (pandas, scikit-learn), and integration with other tools.\n- High demand for Python programmers in data science roles.\n\n**2. R:**\n- Popular choice for data analysis and visualization, particularly in academia and research.\n- Extensive libraries for statistical modeling and data wrangling.\n\n**3. Java:**\n- Enterprise-grade platform for data science, with strong performance and scalability.\n- Widely used in data mining and big data analytics.\n\n**4. SQL:**\n- Essential for data querying and manipulation, especially in relational databases.\n- Used for data analysis and visualization in various industries.\n\n**5. Scala:**\n- Scalable and efficient for big data processing and machine learning models.\n- Popular in data science for its parallelism and integration with Spark and Spark MLlib."
}

Risoluzione dei problemi

  • Se viene visualizzato il messaggio Empty reply from server, è possibile che il contenitore non abbia completato il download dei dati del modello. Controlla di nuovo nei log del pod il messaggio Connected che indica che il modello è pronto per la pubblicazione.
  • Se vedi Connection refused, verifica che il port forwarding sia attivo.

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 le risorse di cui è stato eseguito il deployment

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse creati in questa guida, esegui questi comandi e segui le istruzioni:

gcloud container clusters delete CLUSTER_NAME --region=REGION

gcloud iam service-accounts delete wi-jetstream@PROJECT_ID.iam.gserviceaccount.com

gcloud storage rm --recursive gs://BUCKET_NAME

Passaggi successivi