Gestisci modelli aperti Gemma utilizzando GPU su GKE con Hugging Face TGI

Questo tutorial mostra come gestire Gemma, una famiglia di modelli aperti, una famiglia di modelli linguistici di grandi dimensioni (LLM), utilizzando le unità di elaborazione grafiche (GPU) su Google Kubernetes Engine (GKE) con il framework di distribuzione Text Generation Inference (TGI) di Hugging Face. In questo tutorial, scarica i modelli della famiglia Gemma preaddestrati con parametri 2B e 7B e li eseguirai con istruzioni ottimizzate da Hugging Face ed eseguirai il deployment su un cluster GKE Autopilot o Standard utilizzando un container che esegue TGI.

Questa guida è un buon punto di partenza se hai bisogno del controllo granulare, della scalabilità, della resilienza, della portabilità e della convenienza economica di Kubernetes gestito durante il deployment e la gestione dei tuoi carichi di lavoro di AI/ML. Se hai bisogno di una piattaforma di IA gestita unificata per creare e gestire rapidamente modelli ML in modo conveniente, ti consigliamo di provare la nostra soluzione di deployment Vertex AI.

Contesto

Se gestisci Gemma utilizzando GPU su GKE con TGI, puoi implementare una soluzione solida e pronta per l'inferenza pronta per la produzione che vanta tutti i vantaggi di Kubernetes gestito, tra cui scalabilità efficiente e disponibilità superiore. 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 licenza aperta. Questi modelli di IA possono essere eseguiti su applicazioni, hardware, dispositivi mobili o servizi in hosting.

In questa guida introduciamo i seguenti modelli:

  • Gemma per la generazione di testo, puoi anche ottimizzare questi modelli per specializzarti nell'esecuzione di attività specifiche.
  • CodeGemma è una raccolta di modelli leggeri e potenti che possono eseguire una varietà di attività di programmazione come il completamento del codice full-in-the- middle, la generazione di codice, la comprensione del linguaggio naturale, il ragionamento matematico e la seguire le istruzioni.

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

GPU

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

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

  1. Scopri di più sulla disponibilità attuale della versione GPU
  2. Scopri di più sulle GPU in GKE

Inferenza generazione testo (TGI)

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

Per scoprire di più, consulta la documentazione di TGI.

Obiettivi

Questa guida è rivolta ai clienti di IA generativa che utilizzano PyTorch, agli utenti nuovi o esistenti di GKE, ingegneri ML, MLOps (DevOps) o amministratori di piattaforma interessati a utilizzare le funzionalità di orchestrazione dei container Kubernetes per gestire LLM su hardware GPU H100, A100 e L4.

Alla fine di questa guida, sarai in grado di:

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

Prima di iniziare

  • Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

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

    Go to project selector

  • Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  • Attiva l'API richiesta.

    Abilita l'API

    •

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

    Go to project selector

  • Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  • Attiva l'API richiesta.

    Abilita l'API

    •

  • Assicurati di disporre dei seguenti ruoli nel progetto: roles/container.admin, roles/iam.serviceAccountAdmin

    Verifica i ruoli

    1. Nella console Google Cloud, vai alla pagina IAM.

      Vai a IAM
    2. Seleziona il progetto.

    3. Nella colonna Entità, individua la riga contenente il tuo indirizzo email.

      Se il tuo indirizzo email non è in questa colonna, significa che non disponi di alcun ruolo.

    4. Nella colonna Ruolo per la riga contenente il tuo indirizzo email, controlla se l'elenco dei ruoli include quelli richiesti.

    Concedi i ruoli

    1. Nella console Google Cloud, vai alla pagina IAM.

      Vai a IAM
    2. Seleziona il progetto.
    3. Fai clic su Concedi l'accesso.
    4. Nel campo Nuove entità, inserisci il tuo indirizzo email.
    5. Nell'elenco Seleziona un ruolo, scegli un ruolo.
    6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ciascun ruolo aggiuntivo.
    7. Fai clic su Salva.

Ottieni l'accesso al modello

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

Devi firmare il contratto di consenso per utilizzare Gemma. 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.

Genera un token di accesso

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

Segui questa procedura per generare un nuovo token, se non ne hai già uno:

  1. Fai clic su Il tuo profilo > Impostazioni > Token di accesso.
  2. Seleziona New Token (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 è preinstallato con il software necessario 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 nel 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 REGION=REGION
export CLUSTER_NAME=tgi
export HF_TOKEN=HF_TOKEN

    Sostituisci i seguenti valori:

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

Creazione e configurazione delle 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, vedi Scegliere una modalità operativa di GKE.

Autopilot

In Cloud Shell, esegui questo comando:

gcloud container clusters create-auto ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${REGION} \
  --release-channel=rapid \
  --cluster-version=1.28

GKE crea un cluster Autopilot con nodi di 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

    La creazione del cluster potrebbe richiedere diversi minuti.

  2. Esegui questo comando per creare un pool di nodi per il tuo cluster:

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

Creare un secret Kubernetes per le credenziali di Hugging Face

In Cloud Shell, segui questi passaggi:

  1. Configura kubectl per comunicare con il tuo cluster:

    gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}

  2. Crea un secret Kubernetes che contiene 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 -

Esegui il deployment di TGI

In questa sezione eseguirai il deployment del container TGI per gestire il modello Gemma che vuoi utilizzare. Per scoprire di più sui modelli ottimizzati e preaddestrati per le istruzioni e su quale selezionare per il tuo caso d'uso, consulta Modelli ottimizzati.

Esegui il deployment di un modello Gemma ottimizzato per le istruzioni

Segui queste istruzioni se vuoi eseguire il deployment di un modello o di una variante Gemma ottimizzato per le istruzioni.

Gemma 2B-it

Segui queste istruzioni per eseguire il deployment del modello ottimizzato per l'istruzione Gemma 2B.

  1. Crea il seguente manifest tgi-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-2b-1.1-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: 1
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=1
        env:
        - name: MODEL_ID
          value: google/gemma-1.1-2b-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-2b-it.yaml

Gemma 7B-it

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

  1. Crea il seguente manifest tgi-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: gemma-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: ghcr.io/huggingface/text-generation-inference:2.0.2
        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/gemma-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-7b-it.yaml

CodeGemma 7B-it

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

  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: ghcr.io/huggingface/text-generation-inference:2.0.2
        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

Esegui il deployment di un modello Gemma preaddestrato

Segui queste istruzioni se vuoi eseguire il deployment di un modello o di una variante Gemma preaddestrata.

Gemma 2B

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

  1. Crea il seguente manifest tgi-2b.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-2b
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=1
        env:
        - name: MODEL_ID
          value: google/gemma-2b
        - 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-2b.yaml

Gemma 7B

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

  1. Crea il seguente manifest tgi-7b.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-7b
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        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/gemma-7b
        - 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-7b.yaml

CodeGemma 2B

Segui queste istruzioni per eseguire il deployment del modello preaddestrato CodeGemma 2B.

  1. Crea il seguente manifest tgi-codegemma-1.1-2b.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-2b
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=1
        env:
        - name: MODEL_ID
          value: google/codegemma-1.1-2b
        - 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-2b.yaml

Un pod nel cluster scarica i pesi del modello da Hugging Face e avvia il motore di gestione.

Attendi che il deployment sia disponibile:

kubectl wait --for=condition=Available --timeout=700s deployment/tgi-gemma-deployment

Visualizza i log del deployment in esecuzione:

kubectl logs -f -l app=gemma-server

La risorsa Deployment scarica i dati del modello. Questa procedura può richiedere alcuni minuti. L'output è simile al seguente:

2024-05-08T20:27:37.557836Z  INFO text_generation_router: router/src/main.rs:317: Warming up model
2024-05-08T20:27:39.206371Z  INFO text_generation_launcher: Cuda Graphs are enabled for sizes [1, 2, 4, 8, 16, 32]
2024-05-08T20:27:40.461998Z  INFO text_generation_router: router/src/main.rs:354: Setting max batch total tokens to 632992
2024-05-08T20:27:40.462018Z  INFO text_generation_router: router/src/main.rs:355: Connected
2024-05-08T20:27:40.462025Z  WARN text_generation_router: router/src/main.rs:369: Invalid hostname, defaulting to 0.0.0.0

Assicurati che il modello sia stato scaricato completamente prima di procedere con la sezione successiva.

Pubblica il modello

In questa sezione devi interagire con il modello.

Configura 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

Interagire con il modello utilizzando curl

Questa sezione mostra come eseguire un test di fumo di base per verificare i modelli preaddestrati o ottimizzati per le istruzioni di cui è stato eseguito il deployment. Per semplicità, questa sezione descrive l'approccio al test utilizzando i modelli ottimizzati per l'istruzione Gemma 2B, ottimizzati per l'istruzione Gemma 2B e CodeGemma 7B.

Gemma 2B-it

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 della 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* **"}

Gemma 2B

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

USER_PROMPT="Java is a"

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

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

{"generated_text":" general-purpose, high-level, class-based, object-oriented programming language. <strong>Is Java a statically typed language?</strong> Yes, Java is a statically typed language. Java also supports dynamic typing. Static typing means that the type of every variable is explicitly specified at the time of declaration. The type can be either implicit or explicit. Static typing means that if no types are assigned then it will be assumed as a primitive type.\n\n<h3>What is Java?</h3>\n\nJava is a general-purpose, class-based, object-oriented programming language. Java is one of the oldest programming languages that has gained a"}

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 della 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) Interagire con il modello tramite un'interfaccia di chat con Google Radio.

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

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

Esegui il deployment dell'interfaccia di chat

  1. In Cloud Shell, salva il manifest seguente 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.3
        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

    Viene creato un port forwarding da Cloud Shell al servizio Gradio.

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

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

Risoluzione dei problemi

  • Se viene visualizzato il messaggio Empty reply from server, è possibile che il contenitore non abbia terminato 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 create in questa guida, esegui questo comando:

gcloud container clusters delete ${CLUSTER_NAME} \
  --region=${REGION}

Passaggi successivi