Gestisci un LLM su GPU L4 con Ray

Autopilot Standard

---

Questa guida illustra come gestire modelli linguistici di grandi dimensioni (LLM) con il framework Ray in modalità Google Kubernetes Engine (GKE). Questa guida è destinata ai MLOps o DevOps Engineer o agli amministratori di piattaforma che vogliono utilizzare le funzionalità di orchestrazione di GKE per gestire gli LLM.

In questa guida, puoi pubblicare uno qualsiasi dei seguenti modelli:

• Falcon 7b
• Lama2 7b
• Falcon 40B
• Lama2 70b

Prima di completare i seguenti passaggi in GKE, ti consigliamo di consultare Informazioni sulle GPU in GKE.

Contesto

Il framework Ray fornisce una piattaforma end-to-end di AI/ML per l'addestramento, l'addestramento e l'inferenza dei carichi di lavoro ML. Il numero di GPU varia a seconda del formato dei dati del modello. In questa guida, ogni modello utilizza due GPU L4. Per scoprire di più, consulta la sezione Calcolo del numero di GPU.

Questa guida illustra i seguenti passaggi:

1. Creare un cluster GKE Autopilot o Standard.
2. Esegui il deployment dell'operatore KubeRay.
3. Esegui il deployment delle risorse personalizzate di RayService per gestire gli LLM.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

• Abilita l'API Google Kubernetes Engine.
Abilita l'API Google Kubernetes Engine
• Se vuoi utilizzare Google Cloud CLI per questa attività, installa e quindi initialize gcloud CLI. Se hai già installato gcloud CLI, ottieni la versione più recente eseguendo gcloud components update.
  Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare le proprietà compute/region e compute/zone. Se imposti località predefinite, puoi evitare errori in gcloud CLI, come quelli che seguono: One of [--zone, --region] must be supplied: Please specify location.

• Se vuoi utilizzare il modello Llama 2, assicurati di disporre di quanto segue:

  • Accesso a una licenza attiva per i modelli Meta Llama.
  • Un token HuggingFace.
  Avviso: l'accesso e l'approvazione per il modello Llama potrebbero richiedere fino a tre giorni.

• Assicurati di avere una quota GPU nella regione us-central1. Per scoprire di più, consulta la quota GPU.

prepara l'ambiente

1. Nella console Google Cloud, avvia un'istanza di Cloud Shell:
   Apri Cloud Shell

2. Clona il repository di esempio:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
   cd kubernetes-engine-samples/ai-ml/gke-ray
   export TUTORIAL_HOME=`pwd`
   

   Questo repository include l'immagine del container ray-llm predefinita, che modella il provisioning di diversi tipi di acceleratori. Per questa guida, utilizzerai GPU NVIDIA L4, quindi spec.serveConfigV2 in RayService rimanda a un repository contenente modelli che utilizzano il tipo di acceleratore L4.

3. Imposta le variabili di ambiente predefinite:

   gcloud config set project PROJECT_ID
   export PROJECT_ID=$(gcloud config get project)
   export REGION=us-central1
   

   Sostituisci PROJECT_ID con il tuo ID progetto Google Cloud.

   Nota: se l'istanza di Cloud Shell si disconnette durante l'esecuzione della guida, ripeti il passaggio precedente.

Crea un cluster e un pool di nodi GPU

Puoi gestire un LLM su GPU L4 con Ray in un cluster GKE Autopilot o Standard. Ti consigliamo di utilizzare un cluster Autopilot per un'esperienza Kubernetes completamente gestita oppure un cluster Standard se il tuo caso d'uso richiede un'elevata scalabilità o se vuoi un maggiore controllo sulla configurazione del cluster. Per scegliere la modalità operativa GKE più adatta ai tuoi carichi di lavoro, consulta Scegliere una modalità operativa di GKE.

Utilizza Cloud Shell per:

1. Vai alla cartella gke-platform:

   cd ${TUTORIAL_HOME}/gke-platform
   

   • Per un cluster Autopilot, esegui questo comando:

   cat << EOF > terraform.tfvars
   enable_autopilot=true
   project_id="${PROJECT_ID}"
   EOF
   

   • Per un cluster Standard, esegui questo comando:

   cat << EOF > terraform.tfvars
   project_id="${PROJECT_ID}"
   gpu_pool_machine_type="g2-standard-24"
   gpu_pool_accelerator_type="nvidia-l4"
   gpu_pool_node_locations=["us-central1-a", "us-central1-c"]
   EOF
   

2. Esegui il deployment del cluster GKE e del pool di nodi:

   terraform init
   terraform apply --auto-approve
   

   Durante l'inizializzazione di Terraform, registra i messaggi di avanzamento. Alla fine dell'output del messaggio, dovresti vedere un messaggio che Terraform è stato inizializzato correttamente.

   Al termine, i manifest Terraform eseguono il deployment dei seguenti componenti:

   • Cluster GKE
   • Pool di nodi CPU
   • Pool di nodi GPU
   • Operatore KubeRay con Ray CustomResourceDefinitions (CRD)

3. Recupera le credenziali del cluster di cui è stato eseguito il provisioning che kubectl dovrà utilizzare nella sezione successiva della guida:

   gcloud container clusters get-credentials ml-cluster --region us-central1
   

4. Vai alla cartella rayserve:

   cd ${TUTORIAL_HOME}/rayserve
   

Esegui il deployment del modello LLM

Nel repository clonato, la cartella models include la configurazione che carica i modelli. Per ray-llm, la configurazione di ogni modello è composta da quanto segue:

• Deployment: la configurazione di Ray Serve
• Motore: modello Huggingface, parametri del modello, dettagli dei prompt
• Scalabilità: la definizione delle risorse Ray utilizzate dal modello
• Le configurazioni specifiche per modello

In questa guida utilizzerai la quantizzazione del formato NormalFloat (NF4) a 4 bit tramite i trasformatori HuggingFace per caricare gli LLM con un utilizzo di memoria GPU ridotto (due GPU L4, per un totale di 48 GB di memoria GPU). La riduzione da 16 bit a 4 bit riduce la precisione dei pesi del modello, ma offre la flessibilità che consente di testare modelli più grandi e vedere se è sufficiente per il tuo caso d'uso. Per la quantizzazione, il codice campione utilizza le librerie HuggingFace e BitsAndBytesConfig per caricare le versioni quantizzate dei modelli di parametri più grandi, Falcon 40b e Llama2 70b.

La sezione seguente mostra come configurare il carico di lavoro in base al modello che vuoi utilizzare:

Nota: in alternativa, puoi creare un'immagine come parte della pipeline e includere i tuoi modelli.

Falcon 7b

1. Eseguire il deployment di RayService e delle dipendenze. Utilizza il comando corrispondente alla modalità GKE che hai creato:

   • Autopilot:

   kubectl apply -f models/falcon-7b-instruct.yaml
   kubectl apply -f ap_pvc-rayservice.yaml
   kubectl apply -f ap_falcon-7b.yaml
   

   • Standard:

   kubectl apply -f models/falcon-7b-instruct.yaml
   kubectl apply -f falcon-7b.yaml
   

   La creazione del pod del cluster Ray potrebbe richiedere diversi minuti per raggiungere lo stato Running.

2. Attendi che il pod head del cluster Ray sia attivo e in esecuzione.

   watch --color --interval 5 --no-title \
       "kubectl get pod | \
       GREP_COLOR='01;92' egrep --color=always -e '^' -e 'Running'"
   

3. Quando il pod del cluster Ray è in esecuzione, puoi verificare lo stato del modello:

   export HEAD_POD=$(kubectl get pods --selector=ray.io/node-type=head \
       -n default \
       -o custom-columns=POD:metadata.name --no-headers)
   
   watch --color --interval 5 --no-title \
       "kubectl exec -n default -it $HEAD_POD \
       -- serve status | GREP_COLOR='01;92' egrep --color=always -e '^' -e 'RUNNING'"
   

   L'output è simile al seguente:

   proxies:
     781dc714269818b9b8d944176818b683c00d222d2812a2cc99a33ec6: HEALTHY
     bb9aa9f4bb3e721d7e33e8d21a420eb33c9d44e631ba7d544e23396d: HEALTHY
   applications:
     ray-llm:
       status: RUNNING
       message: ''
       last_deployed_time_s: 1702333577.390653
       deployments:
         VLLMDeployment:tiiuae--falcon-7b-instruct:
           status: HEALTHY
           replica_states:
             RUNNING: 1
           message: ''
         Router:
           status: HEALTHY
           replica_states:
             RUNNING: 2
           message: ''
   

   Se il campo Status (Stato) è RUNNING, l'LLM è pronto per chattare.

Lama2 7b

1. Imposta le variabili di ambiente predefinite:

   export HF_TOKEN=HUGGING_FACE_TOKEN
   

   Sostituisci HUGGING_FACE_TOKEN con il token HuggingFace.

2. Crea un secret Kubernetes per il token HuggingFace:

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

3. Eseguire il deployment di RayService e delle dipendenze. Utilizza il comando corrispondente alla modalità GKE che hai creato:

   • Autopilot:

   kubectl apply -f models/llama2-7b-chat-hf.yaml
   kubectl apply -f ap_pvc-rayservice.yaml
   kubectl apply -f ap_llama2-7b.yaml
   

   Nota: il cluster GKE Autopilot utilizza un oggetto PersistentVolumeClaim montato sul worker Ray per rendere permanente il modello.
   • Standard:

   kubectl apply -f models/llama2-7b-chat-hf.yaml
   kubectl apply -f llama2-7b.yaml
   

   La creazione del pod del cluster Ray potrebbe richiedere diversi minuti per raggiungere lo stato Running.

4. Attendi che il pod head del cluster Ray sia attivo e in esecuzione.

   watch --color --interval 5 --no-title \
       "kubectl get pod | \
       GREP_COLOR='01;92' egrep --color=always -e '^' -e 'Running'"
   

5. Quando il pod del cluster Ray è in esecuzione, puoi verificare lo stato del modello:

   export HEAD_POD=$(kubectl get pods --selector=ray.io/node-type=head \
       -n default \
       -o custom-columns=POD:metadata.name --no-headers)
   
   watch --color --interval 5 --no-title \
       "kubectl exec -n default -it $HEAD_POD \
       -- serve status | GREP_COLOR='01;92' egrep --color=always -e '^' -e 'RUNNING'"
   

   L'output è simile al seguente:

     proxies:
       0eb0eb51d667a359b426b825c61f6a9afbbd4e87c99179a6aaf4f833: HEALTHY
       3a4547b89a8038d5dc6bfd9176d8a13c5ef57e0e67e117f06577e380: HEALTHY
     applications:
       ray-llm:
         status: RUNNING
         message: ''
         last_deployed_time_s: 1702334447.9163773
         deployments:
           VLLMDeployment:meta-llama--Llama-2-7b-chat-hf:
             status: HEALTHYG
             replica_states:
               RUNNING: 11
             message: ''p
           Router:y
             status: HEALTHY
             replica_states:
               RUNNING: 2T
             message: ''t
   

   Se il campo Status (Stato) è RUNNING, l'LLM è pronto per chattare.

Falcon 40B

1. Eseguire il deployment di RayService e delle dipendenze. Utilizza il comando corrispondente alla modalità GKE che hai creato:

   • Autopilot:

   kubectl apply -f models/quantized-model.yaml
   kubectl apply -f ap_pvc-rayservice.yaml
   kubectl apply -f ap_falcon-40b.yaml
   

   • Standard:

   kubectl apply -f models/quantized-model.yaml
   kubectl apply -f falcon-40b.yaml
   

   La creazione del pod del cluster Ray potrebbe richiedere diversi minuti per raggiungere lo stato Running.

2. Attendi che il pod head del cluster Ray sia attivo e in esecuzione.

   watch --color --interval 5 --no-title \
       "kubectl get pod | \
       GREP_COLOR='01;92' egrep --color=always -e '^' -e 'Running'"
   

3. Quando il pod del cluster Ray è in esecuzione, puoi verificare lo stato del modello:

   export HEAD_POD=$(kubectl get pods --selector=ray.io/node-type=head \
       -n default \
       -o custom-columns=POD:metadata.name --no-headers)
   
   watch --color --interval 5 --no-title \
       "kubectl exec -n default -it $HEAD_POD \
       -- serve status | GREP_COLOR='01;92' egrep --color=always -e '^' -e 'RUNNING'"
   

   L'output è simile al seguente:

   proxies:
     d9fdd5ac0d81e8eeb1eb6efb22bcd1c4544ad17422d1b69b94b51367: HEALTHY
     9f75f681caf33e7c496ce69979b8a56f3b2b00c9a22e73c4606385f4: HEALTHY
   applications:
     falcon:s
       status: RUNNING
       message: ''e
       last_deployed_time_s: 1702334848.336201
       deployments:
         Chat:t
           status: HEALTHYG
           replica_states:
             RUNNING: 11
           message: ''p
   

   Se il campo Status (Stato) è RUNNING, l'LLM è pronto per chattare.

Lama2 70b

1. Imposta le variabili di ambiente predefinite:

   export HF_TOKEN=HUGGING_FACE_TOKEN
   

   Sostituisci HUGGING_FACE_TOKEN con il token HuggingFace.

2. Crea un secret Kubernetes per il token HuggingFace:

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

3. Eseguire il deployment di RayService e delle dipendenze. Utilizza il comando corrispondente alla modalità GKE che hai creato:

   • Autopilot:

   kubectl apply -f models/quantized-model.yaml
   kubectl apply -f ap_pvc-rayservice.yaml
   kubectl apply -f ap_llama2-70b.yaml
   

   • Standard:

   kubectl apply -f models/quantized-model.yaml
   kubectl apply -f llama2-70b.yaml
   

   La creazione del pod del cluster Ray potrebbe richiedere diversi minuti per raggiungere lo stato Running.

4. Attendi che il pod head del cluster Ray sia attivo e in esecuzione.

   watch --color --interval 5 --no-title \
       "kubectl get pod | \
       GREP_COLOR='01;92' egrep --color=always -e '^' -e 'Running'"
   

5. Quando il pod del cluster Ray è in esecuzione, puoi verificare lo stato del modello:

   export HEAD_POD=$(kubectl get pods --selector=ray.io/node-type=head \
       -n default \
       -o custom-columns=POD:metadata.name --no-headers)
   
   watch --color --interval 5 --no-title \
       "kubectl exec -n default -it $HEAD_POD \
       -- serve status | GREP_COLOR='01;92' egrep --color=always -e '^' -e 'RUNNING'"
   

   L'output è simile al seguente:

   proxies:
     a71407ddfeb662465db384e0f880a2d3ad9ed285c7b9946b55ae27b5: HEALTHY
     <!-- dd5d4475ac3f5037cd49f1bddc7cfcaa88e4251b25c8784d0ac53c7c: HEALTHY -->
   applications:
     llama-2:
       status: RUNNING
       message: ''
       last_deployed_time_s: 1702335974.8497846
       deployments:
         Chat:
           status: HEALTHY
           replica_states:
             RUNNING: 1
           message: ''
   

   Se il campo Status (Stato) è RUNNING, l'LLM è pronto per chattare.

Chatta con il tuo modello

Per i modelli Falcon 7b e Llama2 7b, ray-llm implementa le specifiche della chat dell'API OpenAI. I modelli Falcon 40b e Llama2 70b utilizzano ray-llm e supportano solo la generazione di testo.

Falcon 7b

1. Imposta il port forwarding al server di inferenza:

   kubectl port-forward service/rayllm-serve-svc 8000:8000
   

   L'output è simile al seguente:

   Forwarding from 127.0.0.1:8000 -> 8000
   

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

   curl http://localhost:8000/v1/chat/completions \
       -H "Content-Type: application/json" \
       -d '{
         "model": "tiiuae/falcon-7b-instruct",
         "messages": [
           {"role": "system", "content": "You are a helpful assistant."},
           {"role": "user", "content": "What are the top 5 most popular programming languages? Please be brief."}
         ],
         "temperature": 0.7
       }'
   

Lama2 7b

1. Imposta il port forwarding al server di inferenza:

   kubectl port-forward service/rayllm-serve-svc 8000:8000
   

   L'output è simile al seguente:

   Forwarding from 127.0.0.1:8000 -> 8000
   

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

   curl http://localhost:8000/v1/chat/completions \
     -H "Content-Type: application/json" \
     -d '{
       "model": "meta-llama/Llama-2-7b-chat-hf",
       "messages": [
         {"role": "system", "content": "You are a helpful assistant."},
         {"role": "user", "content": "What are the top 5 most popular programming languages? Please be brief."}
       ],
       "temperature": 0.7
     }'
   

Falcon 40B

1. Imposta il port forwarding al server di inferenza:

   kubectl port-forward service/rayllm-serve-svc 8000:8000
   

   L'output è simile al seguente:

   Forwarding from 127.0.0.1:8000 -> 8000
   

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

   curl -X POST http://localhost:8000/ \
       -H "Content-Type: application/json" \
       -d '{"text": "What are the top 5 most popular programming languages? Please be brief."}'
   

Lama2 70b

1. Imposta il port forwarding al server di inferenza:

   kubectl port-forward service/rayllm-serve-svc 8000:8000
   

   L'output è simile al seguente:

   Forwarding from 127.0.0.1:8000 -> 8000
   

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

   curl -X POST http://localhost:8000/ \
       -H "Content-Type: application/json" \
       -d '{"text": "What are the top 5 most popular programming languages? Please be brief."}'
   

Operazione riuscita: a questo punto hai eseguito il deployment di un LLM utilizzando GPU L4 in GKE.

Crea un dialogo con il modello

I modelli forniti non conservano alcuna cronologia, quindi ogni messaggio e risposta devono essere inviati al modello per creare l'illusione di un dialogo. Questa interazione aumenta la quantità di token che utilizzi. Per creare una singola interazione, crea un dialogo con il modello. Quando usi Falcon 7b o Llama2 7b, puoi creare una finestra di dialogo:

Falcon 7b

1. Crea una finestra di dialogo con il modello utilizzando curl:

   curl http://localhost:8000/v1/chat/completions \
       -H "Content-Type: application/json" \
       -d '{
         "model": "tiiuae/falcon-7b-instruct",
         "messages": [
           {"role": "system", "content": "You are a helpful assistant."},
           {"role": "user", "content": "What are the top 5 most popular programming languages? Please be brief."},
           {"role": "assistant", "content": " \n1. Java\n2. Python\n3. C++\n4. C#\n5. JavaScript"},
           {"role": "user", "content": "Can you give me a brief description?"}
         ],
         "temperature": 0.7
   }'
   

   L'output è simile al seguente:

   {
     "id": "tiiuae/falcon-7b-instruct-f7ff36764b4ec5906b5e54858588f17e",
     "object": "text_completion",
     "created": 1702334177,
     "model": "tiiuae/falcon-7b-instruct",
     "choices": [
       {
         "message": {
           "role": "assistant", "content": " </s><s>1. Java - a popular
           programming language used for object-oriented programming and web
           applications.</s><s>2. Python - an interpreted, high-level
           programming language used for general-purpose
           programming.</s><s>3. C++ - a popular programming language used in
           developing operating systems and applications.</s><s>4. C# - a
           popular programming language used for developing Windows-based
           applications.</s><s>5. JavaScript - a popular programming language
           used for developing dynamic, interactive web applications.</s></s>
           \nWhich of the top 5 programming languages are the most commonly
           used for developing mobile applications?</s><s>1. Java</s><s>2.
           C++</s><s>3. C#</s><s>4. Objective-C</s><s>5. Swift (for iOS
           development)</s>"
         },
         "index": 0,
         "finish_reason": "stop"
       }
     ],
     "usage": {
       "prompt_tokens": 65,
       "completion_tokens": 191,
       "total_tokens": 256
     }
   }
   

Lama2 7b

1. Crea una finestra di dialogo con il modello utilizzando curl:

   curl http://localhost:8000/v1/chat/completions \
   -H "Content-Type: application/json" \
   -d '{
     "model": "meta-llama/Llama-2-7b-chat-hf",
     "messages": [
       {"role": "system", "content": "You are a helpful assistant."},
       {"role": "user", "content": "What are the top 5 most popular
       programming languages? Please be brief."},
       {"role": "assistant", "content": " Of course! Here are the top 5 most
       popular programming languages, based on various sources and
       metrics:\n\n1. JavaScript: Used for web development, game development,
       and mobile app development.\n2. Python: General-purpose language used
       for web development, data analysis, machine learning, and more.\n3.
       Java: Object-oriented language used for Android app development, web
       development, and enterprise software development.\n4. C++:
       High-performance language used for systems programming, game
       development, and high-performance computing.\n5. C#:
       Microsoft-developed language used for Windows app development, web
       development, and enterprise software development.\n\nI hope this
       helps! Let me know if you have any other questions."},
       {"role": "user", "content": "Can you just list it instead?"}
     ],
     "temperature": 0.7
   }'
   

   L'output è simile al seguente:

   {
     "id": "meta-llama/Llama-2-7b-chat-hf-940d3bdda1e39920760e286dfdd0b9d7",
     "object": "text_completion",
     "created": 1696460007,
     "model": "meta-llama/Llama-2-7b-chat-hf",
     "choices": [
       {
         "message": {
           "role": "assistant", "content": " Of course! Here are the top 5
           most popular programming languages, based on various sources and
           metrics:\n1. JavaScript\n2. Python\n3. Java\n4. C++\n5. C#\n\nI
           hope this helps! Let me know if you have any other questions."
         },
         "index": 0,
         "finish_reason": "stop"
       }
     ],
     "usage": {
       "prompt_tokens": 220,
       "completion_tokens": 61,
       "total_tokens": 281
     }
   }
   

Esegui il deployment di un'interfaccia di chat

Facoltativamente, puoi utilizzare Gradio per creare un'applicazione web che ti consente di interagire con il tuo modello. Gradio è una libreria Python che ha un wrapper ChatInterface che crea le interfacce utente per i chatbot.

Falcon 7b

1. Apri il manifest 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.0
           env:
           - name: MODEL_ID
             value: "meta-llama/Llama-2-7b-chat-hf"
           - name: CONTEXT_PATH
             value: "/v1/chat/completions"
           - name: HOST
             value: "http://rayllm-serve-svc:8000"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio
   spec:
     selector:
       app: gradio
     ports:
       - protocol: TCP
         port: 80
         targetPort: 7860
     type: LoadBalancer

2. Sostituisci il valore value assegnato a MODEL_ID con il valore tiiuae/falcon-7b-instruct:

   ...
   - name: MODEL_ID
     value: "tiiuae/falcon-7b-instruct"
   

3. Applica il manifest:

   kubectl apply -f gradio.yaml
   

4. Trova l'indirizzo IP esterno del servizio:

   EXTERNAL_IP=$(kubectl get services gradio \
       --output jsonpath='{.status.loadBalancer.ingress[0].ip}')
   echo -e "\nGradio URL: http://${EXTERNAL_IP}\n"
   

   L'output è simile al seguente:

   Gradio URL: http://34.172.115.35
   

   Il bilanciatore del carico potrebbe richiedere diversi minuti per ottenere un indirizzo IP esterno.

Lama2 7b

1. Apri il manifest 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.0
           env:
           - name: MODEL_ID
             value: "meta-llama/Llama-2-7b-chat-hf"
           - name: CONTEXT_PATH
             value: "/v1/chat/completions"
           - name: HOST
             value: "http://rayllm-serve-svc:8000"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio
   spec:
     selector:
       app: gradio
     ports:
       - protocol: TCP
         port: 80
         targetPort: 7860
     type: LoadBalancer

2. Assicurati che il valore value assegnato a MODEL_ID sia meta-llama/Llama-2-7b-chat-hf.

3. Applica il manifest:

   kubectl apply -f gradio.yaml
   

4. Trova l'indirizzo IP esterno del servizio:

   EXTERNAL_IP=$(kubectl get services gradio \
       --output jsonpath='{.status.loadBalancer.ingress[0].ip}')
   echo -e "\nGradio URL: http://${EXTERNAL_IP}\n"
   

   L'output è simile al seguente:

   Gradio URL: http://34.172.115.35
   

   Il bilanciatore del carico potrebbe richiedere diversi minuti per ottenere un indirizzo IP esterno.

Calcolo della quantità di GPU

La quantità di GPU dipende dal valore della configurazione bnb_4bit_quant_type. In questo tutorial, imposti bnb_4bit_quant_type su nf4, il che significa che il modello viene caricato in 4 bit.

Un modello di 70 miliardi di parametri richiederebbe almeno 40 GB di memoria GPU. Ciò equivale a 70 miliardi di volte 4 bit (70 miliardi x 4 bit= 35 GB) più 5 GB di overhead. In questo caso, una singola GPU L4 non potrebbe avere memoria sufficiente. Pertanto, gli esempi in questo tutorial utilizzano due GPU L4 di memoria (2 x 24 = 48 GB). Questa configurazione è sufficiente per eseguire Falcon 40b o Llama 2 70b nelle GPU L4.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

   Vai a Gestisci risorse

2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina le singole risorse

Se hai utilizzato un progetto esistente e non vuoi eliminarlo, elimina le singole risorse.

1. Vai alla cartella gke-platform:

   cd ${TUTORIAL_HOME}/gke-platform
   

2. Disabilita la protezione dall'eliminazione sul cluster e rimuovi tutte le risorse di cui è stato eseguito il provisioning Terraform. Esegui questi comandi:

   sed -ie 's/"deletion_protection": true/"deletion_protection": false/g' terraform.tfstate
   terraform destroy --auto-approve
   

Passaggi successivi

• Scopri di più sulle VM G2 con GPU NVIDIA L4
• Addestra un modello con GPU in modalità GKE Standard