Pubblica i modelli aperti di Gemma utilizzando le GPU su GKE con TGI di Hugging Face

Questo tutorial mostra come eseguire il deployment e pubblicare modelli linguistici di grandi dimensioni (LLM) utilizzando le GPU su Google Kubernetes Engine (GKE) con il framework di pubblicazione Text Generation Inference (TGI) di Hugging Face. Questo tutorial fornisce le basi per comprendere ed esplorare il deployment pratico di LLM per l'inferenza in un ambiente Kubernetes gestito. Esegui il deployment di un container predefinito che esegue TGI in GKE. Configuri anche GKE per caricare i pesi di Gemma 2B, 9B e 27B da Hugging Face.

Questo tutorial è rivolto a machine learning engineer, amministratori e operatori di piattaforme e specialisti di dati e AI interessati a utilizzare le funzionalità di orchestrazione dei container Kubernetes per gestire LLM su hardware GPU H100, A100 e L4. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti di Google Cloud , consulta la pagina Ruoli e attività comuni degli utenti di GKE Enterprise.

Se hai bisogno di una piattaforma di AI gestita unificata per creare e pubblicare rapidamente modelli ML in modo conveniente, ti consigliamo di provare la nostra soluzione di deployment Vertex AI.

Prima di leggere questa pagina, assicurati di avere familiarità con quanto segue:

Sfondo

Questa sezione descrive le tecnologie chiave utilizzate in questa guida.

Gemma

Gemma è un insieme di modelli di intelligenza artificiale (AI) generativa leggeri e disponibili pubblicamente rilasciati con una licenza aperta. Questi modelli di AI sono disponibili per l'esecuzione nelle tue applicazioni, hardware, dispositivi mobili o servizi ospitati.

In questa guida vengono presentati i seguenti modelli:

  • Gemma per la generazione di testo. Puoi anche ottimizzare questi modelli per specializzarli nell'esecuzione di attività specifiche.
  • CodeGemma è una raccolta di modelli potenti e leggeri in grado di eseguire una serie di attività di programmazione come il completamento del codice di riempimento, la generazione di codice, la comprensione del linguaggio naturale, il ragionamento matematico e l'esecuzione di istruzioni.

Per saperne di più, consulta la documentazione di Gemma.

GPU

Le GPU ti consentono di accelerare carichi di lavoro specifici in esecuzione sui tuoi nodi, come machine learning ed elaborazione di dati. GKE offre una gamma di opzioni di tipo di macchina per la configurazione dei nodi, inclusi i tipi di macchina con GPU NVIDIA H100, L4 e A100.

Text Generation Inference (TGI)

TGI è il toolkit di Hugging Face per il deployment e la pubblicazione di LLM. TGI consente la generazione di testo ad alte prestazioni per i LLM open source più diffusi, tra cui Gemma. TGI include funzionalità come:

Per saperne di più, consulta la documentazione TGI.

Obiettivi

  1. Prepara l'ambiente con un cluster GKE in modalità Autopilot.
  2. Esegui il deployment di TGI nel tuo cluster.
  3. Utilizza TGI per pubblicare il modello Gemma 2 tramite curl e un'interfaccia di chat web.

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 column 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 l'accesso.

    4. Nel campo Nuove entità, inserisci il tuo identificatore dell'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.

      8. Ottenere l'accesso al modello

      Per accedere ai modelli Gemma per il deployment su GKE, devi prima firmare il contratto di consenso alla licenza, quindi generare un token di accesso Hugging Face.

      Per utilizzare Gemma devi firmare il contratto di consenso. Segui queste istruzioni:

      1. Accedi alla pagina del consenso del modello su Kaggle.com.
      2. Verifica il consenso utilizzando il tuo account Hugging Face.
      3. Accetta i termini del modello.

      Generare un token di accesso

      Per accedere al modello tramite Hugging Face, devi disporre di un token Hugging Face.

      Segui questi passaggi per generare un nuovo token se non ne hai già uno:

      1. Fai clic su Il tuo profilo > Impostazioni > Token di accesso.
      2. Seleziona Nuovo token.
      3. Specifica un nome a tua scelta e un ruolo di almeno Read.
      4. Seleziona Genera un token.
      5. Copia il token generato negli appunti.

      prepara l'ambiente

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

      Per configurare l'ambiente con Cloud Shell:

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

      2. Imposta le variabili di ambiente predefinite:

        gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export REGION=REGION
export CLUSTER_NAME=CLUSTER_NAME
export HF_TOKEN=HF_TOKEN

        Sostituisci i seguenti valori:

        • PROJECT_ID: il tuo Google Cloud ID progetto.
        • REGION: una regione che supporta il tipo di acceleratore che vuoi utilizzare, ad esempio us-central1 per la GPU L4.
        • CLUSTER_NAME: il nome del tuo cluster.
        • HF_TOKEN: il token Hugging Face che hai generato in precedenza.

      Creare e configurare risorse Google Cloud

      Segui queste istruzioni per creare le risorse richieste.

      Crea un cluster GKE e un pool di nodi

      Puoi gestire Gemma su GPU 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, consulta Scegliere una modalità operativa GKE.

      Autopilot

      In Cloud Shell, esegui questo comando:

      gcloud container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --region=REGION \
    --release-channel=rapid

      Sostituisci i seguenti valori:

      • PROJECT_ID: il tuo Google Cloud ID progetto.
      • REGION: una regione che supporta il tipo di acceleratore che vuoi utilizzare, ad esempio us-central1 per la GPU L4.
      • CLUSTER_NAME: il nome del tuo cluster.

      GKE crea un cluster Autopilot con nodi CPU e GPU come richiesto dai carichi di lavoro di cui è stato eseguito il deployment.

      Standard

      1. In Cloud Shell, esegui questo comando per creare un cluster Standard:

        gcloud container clusters create CLUSTER_NAME \
    --project=PROJECT_ID \
    --region=REGION \
    --workload-pool=PROJECT_ID.svc.id.goog \
    --release-channel=rapid \
    --num-nodes=1

        Sostituisci i seguenti valori:

        • PROJECT_ID: il tuo Google Cloud ID progetto.
        • REGION: una regione che supporta il tipo di acceleratore che vuoi utilizzare, ad esempio us-central1 per la GPU L4.
        • CLUSTER_NAME: il nome del tuo cluster.

        La creazione del cluster potrebbe richiedere diversi minuti.

      2. Per creare un node pool per il tuo cluster con le dimensioni del disco appropriate, esegui questo comando:

        Gemma 2 2B

        gcloud container node-pools create gpupool \
    --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
    --project=PROJECT_ID \
    --location=REGION \
    --node-locations=REGION-a \
    --cluster=CLUSTER_NAME \
    --machine-type=g2-standard-8 \
    --num-nodes=1

        GKE crea un singolo pool di nodi contenente una GPU L4 per ogni nodo.

        Gemma 2 9B

        gcloud container node-pools create gpupool \
    --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest \
    --project=PROJECT_ID \
    --location=REGION \
    --node-locations=REGION-a \
    --cluster=CLUSTER_NAME \
    --machine-type=g2-standard-24 \
    --num-nodes=1

        GKE crea un singolo pool di nodi contenente due GPU L4 per ogni nodo.

        Gemma 2 27B

        gcloud container node-pools create gpupool \
    --accelerator type=nvidia-l4,count=4,gpu-driver-version=latest \
    --project=PROJECT_ID \
    --location=REGION \
    --node-locations=REGION-a \
    --cluster=CLUSTER_NAME \
    --machine-type=g2-standard-48 \
    --num-nodes=1 \
    --disk-size=180

        GKE crea un singolo pool di nodi contenente quattro GPU L4 per ogni nodo.

      Crea un secret Kubernetes per le credenziali di Hugging Face

      In Cloud Shell:

      1. Configura kubectl per comunicare con il cluster:

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

        Sostituisci i seguenti valori:

        • REGION: una regione che supporta il tipo di acceleratore che vuoi utilizzare, ad esempio us-central1 per la GPU L4.
        • CLUSTER_NAME: il nome del tuo cluster.

      2. Crea un secret di Kubernetes che contenga il token Hugging Face:

        kubectl create secret generic hf-secret \
    --from-literal=hf_api_token=HF_TOKEN \
    --dry-run=client -o yaml | kubectl apply -f -

        Sostituisci HF_TOKEN con il token Hugging Face che hai generato in precedenza.

      Esegui il deployment di TGI

      In questa sezione, esegui il deployment del container TGI per pubblicare il modello Gemma che vuoi utilizzare. Per eseguire il deployment del modello, questo tutorial utilizza i deployment Kubernetes. Un deployment è un oggetto API Kubernetes che consente di eseguire più repliche di pod distribuite tra i nodi di un cluster.

      Gemma 2 2B-it

      Segui queste istruzioni per eseguire il deployment del modello Gemma 2B ottimizzato per le istruzioni.

      1. Crea il seguente manifest tgi-2-2b-it.yaml:

        apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2-2b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
        resources:
          requests:
            cpu: "2"
            memory: "10Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "2"
            memory: "10Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: "1"
        env:
        - name: AIP_HTTP_PORT
          value: '8000'
        - name: NUM_SHARD
          value: '1'
        - name: MAX_INPUT_LENGTH
          value: '1562'
        - name: MAX_TOTAL_TOKENS
          value: '2048'
        - name: MAX_BATCH_PREFILL_TOKENS
          value: '2048'
        - name: CUDA_MEMORY_FRACTION
          value: '0.93'
        - name: MODEL_ID
          value: google/gemma-2-2b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 8000

      2. Applica il manifest:

        kubectl apply -f tgi-2-2b-it.yaml

      Gemma 2 9B-it

      Segui queste istruzioni per eseguire il deployment del modello Gemma 9B ottimizzato per le istruzioni.

      1. Crea il seguente manifest tgi-2-9b-it.yaml:

        apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2-9b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
        resources:
          requests:
            cpu: "4"
            memory: "30Gi"
            ephemeral-storage: "30Gi"
            nvidia.com/gpu: "2"
          limits:
            cpu: "4"
            memory: "30Gi"
            ephemeral-storage: "30Gi"
            nvidia.com/gpu: "2"
        env:
        - name: AIP_HTTP_PORT
          value: '8000'
        - name: NUM_SHARD
          value: '2'
        - name: MAX_INPUT_LENGTH
          value: '1562'
        - name: MAX_TOTAL_TOKENS
          value: '2048'
        - name: MAX_BATCH_PREFILL_TOKENS
          value: '2048'
        - name: CUDA_MEMORY_FRACTION
          value: '0.93'
        - name: MODEL_ID
          value: google/gemma-2-9b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 8000

      2. Applica il manifest:

        kubectl apply -f tgi-2-9b-it.yaml

      Gemma 2 27B-it

      Segui queste istruzioni per eseguire il deployment del modello Gemma 2 27B ottimizzato per le istruzioni.

      1. Crea il seguente manifest tgi-2-27b-it.yaml:

        apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2-27b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
        resources:
          requests:
            cpu: "10"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "4"
          limits:
            cpu: "10"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "4"
        env:
        - name: AIP_HTTP_PORT
          value: '8000'
        - name: NUM_SHARD
          value: '4'
        - name: MAX_INPUT_LENGTH
          value: '1562'
        - name: MAX_TOTAL_TOKENS
          value: '2048'
        - name: MAX_BATCH_PREFILL_TOKENS
          value: '2048'
        - name: CUDA_MEMORY_FRACTION
          value: '0.93'
        - name: MODEL_ID
          value: google/gemma-2-27b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 8000

      2. Applica il manifest:

        kubectl apply -f tgi-2-27b-it.yaml

      CodeGemma 7B-it

      Segui queste istruzioni per eseguire il deployment del modello CodeGemma 7B ottimizzato per le istruzioni.

      1. Crea il seguente manifest tgi-codegemma-1.1-7b-it.yaml:

        apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: codegemma-1.1-7b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
        resources:
          requests:
            cpu: "2"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
          limits:
            cpu: "10"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=2
        env:
        - name: MODEL_ID
          value: google/codegemma-1.1-7b-it
        - name: PORT
          value: "8000"
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

      2. Applica il manifest:

        kubectl apply -f tgi-codegemma-1.1-7b-it.yaml

      Pubblica il modello

      In questa sezione, interagisci con il modello.

      Configurare il port forwarding

      Esegui questo comando per configurare il port forwarding al modello:

      kubectl port-forward service/llm-service 8000:8000

      L'output è simile al seguente:

      Forwarding from 127.0.0.1:8000 -> 8000

      Interagisci con il modello utilizzando curl

      Questa sezione mostra come eseguire un semplice smoke test per verificare i modelli preaddestrati o ottimizzati per le istruzioni di cui è stato eseguito il deployment. Per semplicità, questa sezione descrive l'approccio di test utilizzando i modelli Gemma 2 instruction tuned e CodeGemma.

      Gemma 2

      In una nuova sessione del terminale, utilizza curl per chattare con il tuo modello:

      USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 128
    }
}
EOF

      L'output seguente mostra un esempio di risposta del modello:

      {"generated_text":"**Python**\n\n**Reasons why Python is a great choice for beginners:**\n\n* **Simple syntax:** Python uses clear and concise syntax, making it easy for beginners to pick up.\n* **Easy to learn:** Python's syntax is based on English, making it easier to learn than other languages.\n* **Large and supportive community:** Python has a massive and active community of developers who are constantly willing to help.\n* **Numerous libraries and tools:** Python comes with a vast collection of libraries and tools that make it easy to perform various tasks, such as data manipulation, web development, and machine learning.\n* **"}

      CodeGemma

      In una nuova sessione del terminale, utilizza curl per chattare con il tuo modello:

      USER_PROMPT="Generate a python code example of a adding two numbers from a function called addNumbers"

curl -s -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF | jq -r .generated_text
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 2000
    }
}
EOF

      L'output seguente mostra un esempio di risposta del modello:

      def addNumbers(num1, num2):
  sum = num1 + num2
  return sum

# Get the input from the user
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

# Call the addNumbers function
sum = addNumbers(num1, num2)

# Print the result
print("The sum of", num1, "and", num2, "is", sum)

      (Facoltativo) Interagisci con il modello tramite un'interfaccia di chat Gradio

      In questa sezione, creerai un'applicazione di chat web che ti consente di interagire con il modello ottimizzato per le istruzioni. Per semplicità, questa sezione descrive solo l'approccio di test utilizzando il modello 2B-it.

      Gradio è una libreria Python che ha un wrapper ChatInterface che crea interfacce utente per i chatbot.

      Implementare l'interfaccia di chat

      1. In Cloud Shell, salva il seguente manifest come gradio.yaml:

        apiVersion: apps/v1
kind: Deployment
metadata:
  name: gradio
  labels:
    app: gradio
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gradio
  template:
    metadata:
      labels:
        app: gradio
    spec:
      containers:
      - name: gradio
        image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.4
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "500m"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/generate"
        - name: HOST
          value: "http://llm-service:8000"
        - name: LLM_ENGINE
          value: "tgi"
        - name: MODEL_ID
          value: "gemma"
        - name: USER_PROMPT
          value: "<start_of_turn>user\nprompt<end_of_turn>\n"
        - name: SYSTEM_PROMPT
          value: "<start_of_turn>model\nprompt<end_of_turn>\n"
        ports:
        - containerPort: 7860
---
apiVersion: v1
kind: Service
metadata:
  name: gradio
spec:
  selector:
    app: gradio
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 7860
  type: ClusterIP

      2. Applica il manifest:

        kubectl apply -f gradio.yaml

      3. Attendi che il deployment sia disponibile:

        kubectl wait --for=condition=Available --timeout=300s deployment/gradio

      Utilizzare l'interfaccia di chat

      1. In Cloud Shell, esegui questo comando:

        kubectl port-forward service/gradio 8080:8080

        In questo modo viene creato un port forwarding da Cloud Shell al servizio Gradio.

      2. Fai clic sul pulsante Icona Anteprima web Anteprima web, che si trova in alto a destra nella barra delle app di Cloud Shell. Fai clic su Anteprima sulla porta 8080. Nel browser si apre una nuova scheda.

      3. Interagisci con Gemma utilizzando l'interfaccia di chat di Gradio. Aggiungi un prompt e fai clic su Invia.

      Risoluzione dei problemi

      • Se visualizzi il messaggio Empty reply from server, è possibile che il container non abbia completato il download dei dati del modello. Controlla di nuovo i log del pod per il messaggio Connected che indica che il modello è pronto per essere pubblicato.
      • Se visualizzi Connection refused, verifica che l'inoltro delle porte sia attivo.

      Osserva le prestazioni del modello

      Per osservare le prestazioni del modello, puoi utilizzare l'integrazione della dashboard TGI in Cloud Monitoring. Con questa dashboard puoi visualizzare metriche sul rendimento critiche come il throughput dei token, la latenza delle richieste e i tassi di errore.

      Per utilizzare la dashboard TGI, devi abilitare Google Cloud Managed Service per Prometheus, che raccoglie le metriche da TGI, nel tuo cluster GKE. TGI espone le metriche in formato Prometheus per impostazione predefinita; non è necessario installare un esportatore aggiuntivo.

      Puoi quindi visualizzare le metriche utilizzando la dashboard TGI. Per informazioni sull'utilizzo di Google Cloud Managed Service per Prometheus per raccogliere metriche dal tuo modello, consulta le indicazioni sull'osservabilità di TGI nella documentazione di Cloud Monitoring.

      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 che hai creato in questa guida, esegui questo comando:

      gcloud container clusters delete CLUSTER_NAME \
    --region=REGION

      Sostituisci i seguenti valori:

      • REGION: una regione che supporta il tipo di acceleratore che vuoi utilizzare, ad esempio us-central1 per la GPU L4.
      • CLUSTER_NAME: il nome del tuo cluster.

      Passaggi successivi