Questo tutorial mostra come pubblicare un modello linguistico di grandi dimensioni (LLM) di Gemma utilizzando le unità di elaborazione tensoriale (TPU) su Google Kubernetes Engine (GKE). Esegui il deployment di un container predefinito con JetStream e MaxText su GKE. Inoltre, configura GKE in modo da caricare i pesi di Gemma 7B da Cloud Storage in fase di runtime
Questo tutorial è rivolto a ML engineer, gestori e operatori della piattaforma e a specialisti di dati e AI interessati a utilizzare le funzionalità di orchestrazione dei container Kubernetes per la pubblicazione di LLM. Per approfondire i ruoli comuni e le attività di esempio a cui facciamo riferimento nei contenutiGoogle Cloud , consulta Ruoli e attività comuni degli utenti di GKE Enterprise.
Prima di leggere questa pagina, assicurati di conoscere quanto segue:
- Modalità Autopilot e modalità Standard
- Disponibilità attuale delle versioni TPU con l'architettura di sistema Cloud TPU
- TPU in GKE
Contesto
Questa sezione descrive le tecnologie chiave utilizzate in questo tutorial.
Gemma
Gemma è un insieme di modelli di intelligenza artificiale (AI) generativa leggeri e disponibili pubblicamente, rilasciati con una licenza aperta. Questi modelli di IA possono essere eseguiti nelle tue applicazioni, nel tuo hardware, sui tuoi dispositivi mobili o nei tuoi servizi ospitati. Puoi utilizzare i modelli Gemma per la generazione di testo, ma puoi anche ottimizzarli per attività specializzate.
Per saperne di più, consulta la documentazione di Gemma.
TPU
Le TPU sono circuiti integrati per applicazioni specifiche (ASIC), sviluppati da Google, utilizzati per accelerare i modelli di machine learning e AI creati utilizzando framework come TensorFlow, PyTorch e JAX.
Questo tutorial illustra la pubblicazione del modello Gemma 7B. GKE implementa il modello su nodi TPUv5e a host singolo con topologie TPU configurate in base ai requisiti del modello per la pubblicazione di prompt con bassa latenza.
JetStream
JetStream è un framework per il servizio di inferenza open source sviluppato da Google. JetStream consente l'inferenza ad alte prestazioni, elevata velocità in transito e ottimizzato per la memoria su TPU e GPU. Fornisce ottimizzazioni avanzate delle prestazioni, tra cui tecniche di quantizzazione e batching continuo, per facilitare il deployment di LLM. JetStream consente di eseguire il servizio TPU di PyTorch/XLA e JAX per ottenere prestazioni ottimali.
Per scoprire di più su queste ottimizzazioni, consulta i repository dei progetti JetStream PyTorch e JetStream MaxText.
MaxText
MaxText è un'implementazione di LLM JAX performante, scalabile e adattabile, basata su librerie JAX open source come Flax, Orbax e Optax. L'implementazione di LLM solo per decodificatori di MaxText è scritta in Python. Sfrutta ampiamente il compilatore XLA per ottenere prestazioni elevate senza dover creare kernel personalizzati.
Per scoprire di più sui modelli e sulle dimensioni dei parametri più recenti supportati da MaxText, consulta il repository del progetto MaxText.
Obiettivi
- Prepara un cluster GKE Autopilot o Standard con la topologia TPU consigliata in base alle caratteristiche del modello.
- Esegui il deployment dei componenti JetStream su GKE.
- Ottieni e pubblica il modello ottimizzato per le istruzioni Gemma 7B.
- Pubblica e interagisci con il modello pubblicato.
Architettura
Questa sezione descrive l'architettura GKE utilizzata in questo tutorial. L'architettura comprende un cluster GKE Autopilot o Standard che esegue il provisioning delle TPU e ospita i componenti JetStream per il deployment e la pubblicazione dei modelli.
Il seguente diagramma mostra i componenti di questa architettura:
Questa architettura include i seguenti componenti:
- Un cluster GKE Autopilot o Standard a livello di regione.
- Due pool di nodi con sezione TPU a host singolo che ospitano il deployment di JetStream.
- Il componente Service distribuisce il traffico in entrata a tutte le repliche
JetStream HTTP. JetStream HTTPè un server HTTP che accetta le richieste come wrapper per il formato richiesto da JetStream e le invia al client GRPC di JetStream.Maxengineè un server JetStream che esegue l'inferenza con il batching continuo.
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.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the required API.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the required API.
-
Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin
Check for the roles
-
In the Google Cloud console, go to the IAM page.
Go to IAM - Select the project.
-
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.
- 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
-
In the Google Cloud console, go to the IAM page.
Vai a IAM - Seleziona il progetto.
- Fai clic su Concedi accesso.
-
Nel campo Nuovi principali, inserisci il tuo identificatore utente. In genere si tratta dell'indirizzo email di un Account Google.
- Nell'elenco Seleziona un ruolo, seleziona un ruolo.
- Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo aggiuntivo.
- Fai clic su Salva.
-
- Assicurati di disporre di una quota sufficiente per otto chip PodSlice Lite TPU v5e. In questo tutorial utilizzi le istanze on demand.
- Crea un account Kaggle, se non ne hai già uno.
Ottieni l'accesso al modello
Per accedere al modello Gemma per il deployment in GKE, devi prima firmare il contratto di consenso alla licenza.
Firmare il contratto di consenso per la licenza
Per utilizzare Gemma, devi firmare il contratto di consenso. Segui queste istruzioni:
- Accedi alla pagina del consenso per i modelli Gemma su Kaggle.com.
- Se non l'hai ancora fatto, accedi a Kaggle.
- Fai clic su Richiedi l'accesso.
- Nella sezione Scegli account per il consenso, seleziona Verifica tramite account Kaggle per utilizzare il tuo account Kaggle per il consenso.
- Accetta i Termini e condizioni del modello.
Genera un token di accesso
Per accedere al modello tramite Kaggle, devi disporre di un token API Kaggle.
Se non ne hai già uno, segui questi passaggi per generare un nuovo token:
- Nel browser, vai alle impostazioni di Kaggle.
- Nella sezione API, fai clic su Crea nuovo token.
Viene scaricato un file denominato kaggle.json.
Prepara l'ambiente
In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su
Google Cloud. Cloud Shell include il software di cui avrai bisogno per questo tutorial, tra cui kubectl e
gcloud CLI.
Per configurare l'ambiente con Cloud Shell:
Nella console Google Cloud, avvia una sessione 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 CLUSTER_NAME=CLUSTER_NAME export BUCKET_NAME=BUCKET_NAME export REGION=REGION export LOCATION=LOCATION export CLUSTER_VERSION=CLUSTER_VERSIONSostituisci i seguenti valori:
- PROJECT_ID: il tuo Google Cloud ID progetto.
- CLUSTER_NAME: il nome del tuo cluster GKE.
- BUCKET_NAME: il nome del bucket Cloud Storage.
Non è necessario specificare il prefisso
gs://. - REGION: la regione in cui si trovano il cluster GKE, il bucket Cloud Storage e i nodi TPU. La regione contiene zone in cui sono disponibili tipi di macchine TPU v5e (ad esempio
us-west1,us-west4,us-central1,us-east1,us-east5oeurope-west4). Per i cluster Autopilot, assicurati di disporre di risorse zonali TPU v5e sufficienti per la regione scelta. - (Solo cluster standard) LOCATION: la zona in cui sono disponibili le risorse TPU (ad esempio
us-west4-a). Per i cluster Autopilot, non è necessario specificare la zona, ma solo la regione. CLUSTER_VERSION: la versione di GKE, che deve supportare il tipo di macchina che vuoi utilizzare. Tieni presente che la versione GKE predefinita potrebbe non essere disponibile per la TPU di destinazione. Per un elenco delle versioni GKE minime disponibili per tipo di macchina TPU, consulta Disponibilità delle TPU in GKE.
Crea e configura le risorse Google Cloud
Segui queste istruzioni per creare le risorse richieste.
Crea un cluster GKE
Puoi eseguire Gemma su TPU in un cluster GKE Autopilot o Standard. Ti consigliamo di utilizzare un cluster Autopilot per un'esperienza Kubernetes completamente gestita. Per scegliere la modalità operativa di 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} \
--cluster-version=${CLUSTER_VERSION}
Standard
Crea un cluster GKE Standard regionale che utilizza Workload Identity Federation for GKE.
gcloud container clusters create ${CLUSTER_NAME} \ --enable-ip-alias \ --machine-type=e2-standard-4 \ --num-nodes=2 \ --cluster-version=${CLUSTER_VERSION} \ --workload-pool=${PROJECT_ID}.svc.id.goog \ --location=${REGION}La creazione del cluster potrebbe richiedere diversi minuti.
Esegui il comando seguente per creare un pool di nodi per il cluster:
gcloud container node-pools create gemma-7b-tpu-nodepool \ --cluster=${CLUSTER_NAME} \ --machine-type=ct5lp-hightpu-8t \ --project=${PROJECT_ID} \ --num-nodes=2 \ --region=${REGION} \ --node-locations=${LOCATION}GKE crea un pool di nodi TPU v5e con una topologia
2x4e due nodi.
Crea un bucket Cloud Storage
In Cloud Shell, esegui questo comando:
gcloud storage buckets create gs://${BUCKET_NAME} --location=${REGION}
Viene creato un bucket Cloud Storage per archiviare i file del modello che hai scaricato da Kaggle.
Carica il token di accesso in Cloud Shell
In Cloud Shell, puoi caricare il token dell'API Kaggle nel tuo Google Cloud progetto:
- In Cloud Shell, fai clic su Altro > Carica.
- Seleziona File e fai clic su Scegli file.
- Apri il file
kaggle.json. - Fai clic su Carica.
Crea un secret Kubernetes per le credenziali di Kaggle
In Cloud Shell:
Configura
kubectlper comunicare con il cluster:gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}Crea un secret per archiviare le credenziali di Kaggle:
kubectl create secret generic kaggle-secret \ --from-file=kaggle.json
Configurare l'accesso ai carichi di lavoro utilizzando la federazione delle identità per i carichi di lavoro per GKE
Assegna un account di servizio Kubernetes all'applicazione e configuralo in modo che agisca come account di servizio IAM.
Crea un account di servizio IAM per la tua applicazione:
gcloud iam service-accounts create wi-jetstreamAggiungi un'associazione della policy IAM per il tuo account di servizio IAM per gestire Cloud Storage:
gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \ --role roles/storage.objectUser gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \ --role roles/storage.insightsCollectorServiceConsenti all'account di servizio Kubernetes di simulare l'account di servizio IAM aggiungendo un'associazione dei criteri IAM tra i due account di servizio. Questa associazione consente all'account di servizio Kubernetes di agire come account di servizio IAM:
gcloud iam service-accounts add-iam-policy-binding wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com \ --role roles/iam.workloadIdentityUser \ --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/default]"Annota l'account di servizio Kubernetes con l'indirizzo email dell'account di servizio IAM:
kubectl annotate serviceaccount default \ iam.gke.io/gcp-service-account=wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com
Converti i checkpoint del modello
In questa sezione crei un job per:
- Scarica il checkpoint di base Orbax da Kaggle.
- Carica il checkpoint in un bucket Cloud Storage.
- Converti il checkpoint in un checkpoint compatibile con MaxText.
- Annullare la scansione del checkpoint da utilizzare per la pubblicazione.
Esegui il deployment del job di conversione del checkpoint del modello
Segui queste istruzioni per scaricare e convertire i file checkpoint del modello Gemma 7B.
Crea il seguente manifest come
job-7b.yaml.apiVersion: batch/v1 kind: Job metadata: name: data-loader-7b spec: ttlSecondsAfterFinished: 30 template: spec: restartPolicy: Never containers: - name: inference-checkpoint image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.4 args: - -b=BUCKET_NAME - -m=google/gemma/maxtext/7b-it/2 volumeMounts: - mountPath: "/kaggle/" name: kaggle-credentials readOnly: true resources: requests: google.com/tpu: 8 limits: google.com/tpu: 8 nodeSelector: cloud.google.com/gke-tpu-topology: 2x4 cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice volumes: - name: kaggle-credentials secret: defaultMode: 0400 secretName: kaggle-secretApplica il manifest:
kubectl apply -f job-7b.yamlAttendi che il pod che pianifica il job inizi a funzionare:
kubectl get pod -wL'output sarà simile al seguente. L'operazione potrebbe richiedere alcuni minuti:
NAME READY STATUS RESTARTS AGE data-loader-7b-abcd 0/1 ContainerCreating 0 28s data-loader-7b-abcd 1/1 Running 0 51sPer i cluster Autopilot, potrebbero essere necessari alcuni minuti per il provisioning delle risorse TPU richieste.
Visualizza i log del job:
kubectl logs -f jobs/data-loader-7bAl termine del job, l'output è simile al seguente:
Successfully generated decode checkpoint at: gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items + echo -e '\nCompleted unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items' Completed unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
Esegui il deployment di JetStream
In questa sezione esegui il deployment del contenitore JetStream per pubblicare il modello Gemma.
Segui queste istruzioni per implementare il modello ottimizzato per le istruzioni Gemma 7B. Questo tutorial utilizza un deployment Kubernetes. Un deployment è un oggetto dell'API Kubernetes che ti consente di eseguire più repliche di pod distribuite tra i nodi di un cluster.
Salva il seguente manifest di deployment come
jetstream-gemma-deployment.yaml:apiVersion: apps/v1 kind: Deployment metadata: name: maxengine-server spec: replicas: 1 selector: matchLabels: app: maxengine-server template: metadata: labels: app: maxengine-server spec: nodeSelector: cloud.google.com/gke-tpu-topology: 2x4 cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice containers: - name: maxengine-server image: us-docker.pkg.dev/cloud-tpu-images/inference/maxengine-server:v0.2.2 args: - model_name=gemma-7b - tokenizer_path=assets/tokenizer.gemma - per_device_batch_size=4 - max_prefill_predict_length=1024 - max_target_length=2048 - async_checkpointing=false - ici_fsdp_parallelism=1 - ici_autoregressive_parallelism=-1 - ici_tensor_parallelism=1 - scan_layers=false - weight_dtype=bfloat16 - load_parameters_path=gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items - prometheus_port=PROMETHEUS_PORT ports: - containerPort: 9000 resources: requests: google.com/tpu: 8 limits: google.com/tpu: 8 - name: jetstream-http image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.2 ports: - containerPort: 8000 --- apiVersion: v1 kind: Service metadata: name: jetstream-svc spec: selector: app: maxengine-server ports: - protocol: TCP name: jetstream-http port: 8000 targetPort: 8000 - protocol: TCP name: jetstream-grpc port: 9000 targetPort: 9000Il file manifest imposta le seguenti proprietà chiave:
tokenizer_path: il percorso del tokenizzatore del modello.load_parameters_path: il percorso nel bucket Cloud Storage in cui sono archiviati i checkpoint.per_device_batch_size: la dimensione del batch di decodifica per dispositivo, dove un chip TPU equivale a un dispositivo.max_prefill_predict_length: la lunghezza massima per la precompilazione durante l'autoregressione.max_target_length: la lunghezza massima della sequenza.model_name: il nome del modello (gemma-7b).ici_fsdp_parallelism: il numero di shard per il parallelismo dei dati completamente suddiviso in parti (FSDP).ici_tensor_parallelism: il numero di shard per il parallelismo dei tensori.ici_autoregressive_parallelism: il numero di shard per il parallelismo autoregressivo.prometheus_port: porta per esporre le metriche Prometheus. Rimuovi questo argomento se le metriche non sono necessarie.scan_layers: flag booleano per la scansione dei livelli (booleano).weight_dtype: il tipo di dati del peso (bfloat16).
Applica il manifest:
kubectl apply -f jetstream-gemma-deployment.yamlVerifica il deployment:
kubectl get deploymentL'output è simile al seguente:
NAME READY UP-TO-DATE AVAILABLE AGE maxengine-server 2/2 2 2 ##sPer i cluster Autopilot, potrebbero essere necessari alcuni minuti per il provisioning delle risorse TPU richieste.
Visualizza i log del server HTTP per verificare che il modello sia stato caricato e compilato. Il server potrebbe impiegare alcuni minuti per completare questa operazione.
kubectl logs deploy/maxengine-server -f -c jetstream-httpL'output è simile al seguente:
kubectl logs deploy/maxengine-server -f -c jetstream-http INFO: Started server process [1] INFO: Waiting for application startup. INFO: Application startup complete. INFO: Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)Visualizza i log di MaxEngine e verifica che la compilazione sia stata completata.
kubectl logs deploy/maxengine-server -f -c maxengine-serverL'output è simile al seguente:
2024-03-29 17:09:08,047 - jax._src.dispatch - DEBUG - Finished XLA compilation of jit(initialize) in 0.26236414909362793 sec 2024-03-29 17:09:08,150 - root - INFO - ---------Generate params 0 loaded.---------
Pubblica il modello
In questa sezione interagisci con il modello.
Configurare il port forwarding
Puoi accedere al deployment di JetStream tramite il servizio ClusterIP che hai creato nel passaggio precedente. I servizi ClusterIP sono raggiungibili solo dall'interno del cluster. Pertanto, per accedere al servizio dall'esterno del cluster, completa i seguenti passaggi:
Per stabilire una sessione di inoltro di porte, esegui il seguente comando:
kubectl port-forward svc/jetstream-svc 8000:8000
Interagire con il modello utilizzando curl
Verifica di poter accedere al server HTTP JetStream aprendo un nuovo terminale ed eseguendo il seguente comando:
curl --request POST \ --header "Content-type: application/json" \ -s \ localhost:8000/generate \ --data \ '{ "prompt": "What are the top 5 programming languages", "max_tokens": 200 }'Il completamento della richiesta iniziale può richiedere diversi secondi a causa dell'inizializzazione del modello. L'output è simile al seguente:
{ "response": "\nfor data science in 2023?\n\n**1. Python:**\n- Widely used for data science due to its simplicity, readability, and extensive libraries for data wrangling, analysis, visualization, and machine learning.\n- Popular libraries include pandas, scikit-learn, and matplotlib.\n\n**2. R:**\n- Statistical programming language widely used for data analysis, visualization, and modeling.\n- Popular libraries include ggplot2, dplyr, and caret.\n\n**3. Java:**\n- Enterprise-grade language with strong performance and scalability.\n- Popular libraries include Spark, TensorFlow, and Weka.\n\n**4. C++:**\n- High-performance language often used for data analytics and machine learning models.\n- Popular libraries include TensorFlow, PyTorch, and OpenCV.\n\n**5. SQL:**\n- Relational database language essential for data wrangling and querying large datasets.\n- Popular tools" }
(Facoltativo) Interagire con il modello tramite un'interfaccia di chat di Gradio
In questa sezione, crei un'applicazione di chat web che ti consente di interagire con il tuo modello ottimizzato per le istruzioni.
Gradio è una libreria Python con un wrapperChatInterface che crea 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: "512m" memory: "512Mi" limits: cpu: "1" memory: "512Mi" env: - name: CONTEXT_PATH value: "/generate" - name: HOST value: "http://jetstream-http-svc:8000" - name: LLM_ENGINE value: "max" - 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: ClusterIPApplica il manifest:
kubectl apply -f gradio.yamlAttendi 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:8080Viene creato un port forwarding da Cloud Shell al servizio Gradio.
Fai clic sul pulsante
Anteprima web 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.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 completato il download dei dati del modello. Controlla di nuovo i log del pod per verificare la presenza del messaggioConnectedche indica che il modello è pronto per essere pubblicato. - Se vedi
Connection refused, verifica che l'inoltro delle porte 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 che hai creato in questa guida, esegui i comandi riportati di seguito e segui le istruzioni:
gcloud container clusters delete ${CLUSTER_NAME} --region=${REGION}
gcloud iam service-accounts delete wi-jetstream@PROJECT_ID.iam.gserviceaccount.com
gcloud storage rm --recursive gs://BUCKET_NAME
Passaggi successivi
- Scopri come eseguire modelli Gemma su GKE e come eseguire workload di AI/ML ottimizzati con le funzionalità di orchestrazione della piattaforma GKE.
- Scopri di più sulle TPU in GKE.
- Esplora il repository GitHub di JetStream.
- Esplora Vertex AI Model Garden.