Questa pagina è stata tradotta dall'API Cloud Translation.

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

Autopilota Standard

Questo tutorial mostra come eseguire il servizio della famiglia di modelli aperti Gemma di modelli linguistici di grandi dimensioni (LLM), utilizzando unità di elaborazione grafica (GPU) su Google Kubernetes Engine (GKE) con il framework di pubblicazione Text Generation Inference (TGI) di Hugging Face.

In questo tutorial, scaricherai un Gemma 2 (parametri 2B, 9B e 27B) modello ottimizzato o CodeGemma modello di Hugging Face. Poi esegui il deployment del modello su un cluster GKE Autopilot o Standard utilizzando un contenitore che esegue TGI.

Questa guida è un buon punto di partenza se hai bisogno del controllo granulare, della scalabilità, della resilienza, della portabilità e dell'economicità di Kubernetes gestito per il deployment e l'erogazione dei carichi di lavoro di IA/ML. Se hai bisogno di AI gestita unificata per creare e distribuire rapidamente modelli ML in modo economico, consigliamo di provare la nostra soluzione di deployment Vertex AI.

Sfondo

Se gestisci Gemma utilizzando GPU su GKE con TGI, puoi implementare una soluzione di inferenza solida e pronta per la produzione con tutte vantaggi di Kubernetes gestito, tra cui una scalabilità efficiente e una la disponibilità del servizio. Questa sezione descrive le tecnologie chiave utilizzate in questa guida.

Gemma

Gemma è un insieme di modelli di intelligenza artificiale (IA) generativa leggeri e disponibili pubblicamente, rilasciati con una licenza aperta. Questi modelli di AI sono disponibili per l'esecuzione in 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 in modo che si specializzino 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 ti consentono di accelerare carichi di lavoro specifici in esecuzione sui tuoi nodi, come il machine learning e l'elaborazione di dati. GKE offre una gamma tipi di macchine per la configurazione dei nodi, inclusi i tipi di macchina con NVIDIA H100, GPU L4 e A100.

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

Scopri di più sulla disponibilità attuale della versione di GPU
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 per la generazione di testi ad alte prestazioni per i modelli LLM open source più diffusi, tra cui Gemma. TGI include funzionalità come:

È stata ottimizzata l'implementazione del trasformatore con Flash Attention e PagedAttention
Raggruppamento continuo per migliorare il throughput complessivo della pubblicazione
Parallelismo dei Tensor per un'inferenza più rapida su più GPU

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

Obiettivi

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

Alla fine di questa guida, sarai in grado di:

Prepara l'ambiente con un cluster GKE in Autopilot.
Esegui il deployment di TGI nel tuo cluster.
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 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.

Crea un account Hugging Face, se non ne hai già uno.
Assicurati che il tuo progetto disponga di una quota sufficiente per le GPU. Per scoprire di più, consulta Informazioni sulle GPU e Quote di allocazione.

Ottieni l'accesso al modello

Per accedere ai modelli Gemma per il deployment in GKE, devi prima firmare il contratto di consenso per la licenza e poi generare un token di accesso a Hugging Face.

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

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

Genera un token di accesso

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

Se non ne hai già uno, segui questi passaggi per generare un nuovo token:

Fai clic su Il tuo profilo > Impostazioni > Token di accesso.
Seleziona Nuovo token.
Specifica un nome a tua scelta e un ruolo di almeno Read.
Seleziona Genera un token.
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, inclusi kubectl e con gcloud CLI.

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

Nella console Google Cloud, avvia una sessione di Cloud Shell facendo clic su Attiva Cloud Shell nella console Google Cloud. Viene avviata una sessione nel riquadro inferiore della console Google Cloud.
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 account Google Cloud ID progetto.
- REGION: una regione che supporta l'acceleratore che vuoi 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 ambiente 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

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

Standard

In Cloud Shell, esegui questo comando per creare un'istanza cluster:

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.

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

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

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:

Configura kubectl in modo che comunichi con il tuo cluster:

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

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 l'oggetto Gemma che vuoi utilizzare.

Gemma 2 2B-it

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

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-cu121.2-1.ubuntu2204.py310
        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

Applica il manifest:
```
kubectl apply -f tgi-2-2b-it.yaml
```

Gemma 2 9B-it

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

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-cu121.2-1.ubuntu2204.py310
        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

Applica il manifest:
```
kubectl apply -f tgi-2-9b-it.yaml
```

Gemma 2 27B-it

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

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-cu121.2-1.ubuntu2204.py310
        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

Applica il manifest:
```
kubectl apply -f tgi-2-27b-it.yaml
```

CodeGemma 7B-it

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

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

Applica il manifest:

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

Pubblica il modello

In questa sezione devi interagire con il modello.

Configura il port forwarding

Esegui il seguente 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 l'avvenuta implementazione preaddestrati o ottimizzati per le istruzioni. Per semplicità, questa sezione descrive l'approccio ai test utilizzando l'istruzione di Gemma 2 e i modelli 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

Il seguente output 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

Il seguente output 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) Interagire con il modello tramite un'interfaccia di chat di Gradio

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 di test con il modello 2B-it.

Gradio è una libreria Python che include Wrapper ChatInterface che crea le interfacce utente per i chatbot.

Esegui il deployment dell'interfaccia di Chat

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

Applica il manifest:
```
kubectl apply -f gradio.yaml
```

Attendi che il deployment sia disponibile:

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

Utilizzare l'interfaccia di Chat

In Cloud Shell, esegui questo comando:
```
kubectl port-forward service/gradio 8080:8080
```
Viene creato un port forwarding da Cloud Shell al servizio Gradio.
Fai clic sul pulsante Anteprima web 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.
Interagisci con Gemma utilizzando l'interfaccia di 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 i log del pod per verificare la presenza del messaggio Connected che indica che il modello è pronto per essere pubblicato.
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 creato in questa guida, esegui questo comando:

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

Passaggi successivi

Scopri di più sulle GPU in GKE.
Scopri come utilizzare Gemma con TGI su altri acceleratori, tra cui le GPU A100 e H100, visualizzando il codice di esempio su GitHub.
Scopri come eseguire il deployment dei carichi di lavoro GPU in Autopilot.
Scopri come eseguire il deployment dei carichi di lavoro GPU in Standard.
Consulta la documentazione di TGI.
Esplora Model Garden di Vertex AI.
Scopri come eseguire carichi di lavoro AI/ML ottimizzati con le funzionalità di orchestrazione della piattaforma GKE.

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

Sfondo

Gemma

GPU

Inferenza generazione testo (TGI)

Obiettivi

Prima di iniziare

Check for the roles

Grant the roles

Ottieni l'accesso al modello

Firmare il contratto di consenso per la licenza

Genera un token di accesso

prepara l'ambiente

Creazione e configurazione delle risorse Google Cloud

Crea un cluster GKE e un pool di nodi

Autopilot

Standard

Gemma 2 2B

Gemma 2 9B

Gemma 2 27B

Crea un secret Kubernetes per le credenziali di Hugging Face

Esegui il deployment di TGI

Gemma 2 2B-it

Gemma 2 9B-it

Gemma 2 27B-it

CodeGemma 7B-it

Pubblica il modello

Configura il port forwarding

Interagire con il modello utilizzando curl

Gemma 2

CodeGemma

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

Esegui il deployment dell'interfaccia di Chat

Utilizzare l'interfaccia di Chat

Risoluzione dei problemi

Esegui la pulizia

Elimina le risorse di cui è stato eseguito il deployment

Passaggi successivi