Cette page a été traduite par l'API Cloud Translation.

Diffuser un LLM à l'aide de TPU sur GKE avec JetStream et PyTorch

Ce guide vous explique comment diffuser un grand modèle de langage (LLM) à l'aide des TPU (Tensor Processing Units) sur Google Kubernetes Engine (GKE) avec JetStream via PyTorch. Dans ce guide, vous téléchargez des pondérations de modèle dans Cloud Storage et les déployez sur un cluster GKE Autopilot ou Standard à l'aide d'un conteneur exécutant JetStream

Si vous avez besoin de l'évolutivité, de la résilience et de la rentabilité offertes par les fonctionnalités de Kubernetes lors du déploiement de votre modèle sur JetStream, ce guide est un bon point de départ.

Ce guide est destiné aux clients d'IA générative qui utilisent PyTorch, aux utilisateurs nouveaux ou existants de GKE, aux ingénieurs en ML, aux ingénieurs MLOps (DevOps) ou aux administrateurs de plate-forme qui souhaitent utiliser les fonctionnalités d'orchestration de conteneurs Kubernetes pour diffuser des LLM.

Contexte

En diffusant un LLM à l'aide de TPU sur GKE avec JetStream, vous pouvez créer une solution de diffusion robuste et prête pour la production avec tous les avantages de la plate-forme Kubernetes gérée, y compris en termes de rentabilité, évolutivité et haute disponibilité. Cette section décrit les principales technologies utilisées dans ce tutoriel.

À propos des TPU

Les TPU sont des circuits intégrés propres aux applications (Application-Specific Integrated Circuit ou ASIC), développés spécifiquement par Google et permettant d'accélérer le machine learning et les modèles d'IA créés à l'aide de frameworks tels que TensorFlow, PyTorch et JAX.

Avant d'utiliser des TPU dans GKE, nous vous recommandons de suivre le parcours de formation suivant :

Découvrez la disponibilité actuelle des versions de TPU avec l'architecture système de Cloud TPU.
Apprenez-en plus sur les TPU dans GKE.

Ce tutoriel explique comment diffuser différents modèles LLM. GKE déploie le modèle sur des nœuds TPUv5e à hôte unique avec des topologies TPU configurées en fonction des exigences du modèle pour diffuser des requêtes avec une faible latence.

À propos de JetStream

JetStream est un framework de service d'inférence Open Source développé par Google. JetStream permet des inférences hautes performances, à haut débit et à mémoire optimisée sur les TPU et les GPU. JetStream fournit des optimisations de performances avancées, y compris le traitement par lot continu, les optimisations de cache KV et les techniques de quantification, pour faciliter le déploiement de LLM. JetStream permet de diffuser PyTorch/XLA et JAX TPU pour obtenir des performances optimales.

Traitement par lots continu

Le traitement par lot continu est une technique qui regroupe dynamiquement les requêtes d'inférence entrantes en lots, ce qui réduit la latence et augmente le débit.

Quantification du cache KV

La quantification du cache KV implique de compresser le cache clé-valeur utilisé dans les mécanismes d'attention, ce qui réduit les exigences en mémoire.

Quantification des poids Int8

La quantification des poids Int8 réduit la précision des poids du modèle de 32 bits à virgule flottante à des entiers de 8 bits, ce qui accélère le calcul et réduit l'utilisation de mémoire.

Pour en savoir plus sur ces optimisations, consultez les dépôts de projets JetStream PyTorch et JetStream MaxText.

À propos de PyTorch

PyTorch est un framework de machine learning Open Source développé par Meta et qui fait désormais partie de la Linux Foundation. PyTorch fournit des fonctionnalités de haut niveau, telles que le calcul Tensor et les réseaux de neurones profonds.

Objectifs

Préparer un cluster GKE Autopilot ou standard avec la topologie TPU recommandée en fonction des caractéristiques du modèle.
Déployer des composants JetStream sur GKE.
Obtenir et publier votre modèle.
Diffuser le modèle publié et interagir avec lui.

Architecture

Cette section décrit l'architecture GKE utilisée dans ce tutoriel. L'architecture comprend un cluster GKE Autopilot ou Standard qui provisionne des TPU et héberge des composants JetStream pour déployer et diffuser les modèles.

Le schéma suivant montre les composants de cette architecture :

Architecture d'un cluster GKE avec des pools de nœuds TPU à hôte unique contenant les composants HTTP JetStream-PyTorch et JetStream.

Cette architecture comprend les composants suivants :

Un cluster régional GKE Autopilot ou Standard
Deux pools de nœuds de tranche de TPU à hôte unique qui hébergent le déploiement JetStream.
Le composant de service répartit le trafic entrant sur toutes les instances répliquées JetStream HTTP.
JetStream HTTP est un serveur HTTP qui accepte les requêtes en tant que wrapper pour le format requis de JetStream et les envoie au client GRPC de JetStream.
JetStream-PyTorch est un serveur JetStream qui effectue des inférences avec traitement par lot continu.

Avant de commencer

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the required API.

Enable the API

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the required API.

Enable the API

Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin
Check for the roles
1. In the Google Cloud console, go to the IAM page.
  Go to IAM
2. Select the project.
3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.
4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.
Grant the roles
1. In the Google Cloud console, go to the IAM page.
  Accéder à IAM
2. Sélectionnez le projet.
3. Cliquez sur Accorder l'accès.
4. Dans le champ Nouveaux comptes principaux, saisissez votre identifiant utilisateur. Il s'agit généralement de l'adresse e-mail d'un compte Google.
5. Dans la liste Sélectionner un rôle, sélectionnez un rôle.
6. Pour attribuer des rôles supplémentaires, cliquez sur Ajouter un autre rôle et ajoutez chaque rôle supplémentaire.
7. Cliquez sur Enregistrer.

Assurez-vous de disposer d'un quota suffisant pour huit puces TPU v5e PodSlice Lite. Dans ce tutoriel, vous utilisez des instances à la demande.
Créez un jeton Hugging Face si vous n'en possédez pas.

Accéder au modèle

Accéder à différents modèles sur Hugging Face en vue du déploiement sur GKE

Gemma 7B-it

Pour accéder au modèle Gemma en vue du déploiement sur GKE, vous devez d'abord signer le contrat de consentement de la licence.

Accéder à la page de consentement du modèle Gemma sur Hugging Face
Connectez-vous à Hugging Face si vous ne l'avez pas déjà fait.
Lisez et acceptez les Conditions d'utilisation du modèle.

Llama 3 8B

Pour accéder au modèle Llama 3 en vue du déploiement sur GKE, vous devez d'abord signer le contrat d'autorisation de licence.

Accéder à la page d'autorisation du modèle Llama 3 sur Hugging Face
Connectez-vous à Hugging Face si vous ne l'avez pas déjà fait.
Lisez et acceptez les Conditions d'utilisation du modèle.

Préparer l'environnement

Dans ce tutoriel, vous utilisez Cloud Shell pour gérer les ressources hébergées surGoogle Cloud. Cloud Shell est préinstallé avec les logiciels dont vous avez besoin pour ce tutoriel, y compris kubectl et gcloud CLI.

Pour configurer votre environnement avec Cloud Shell, procédez comme suit :

Dans la console Google Cloud, lancez une session Cloud Shell en cliquant sur Activer Cloud Shell dans la console Google Cloud. Une session s'ouvre dans le volet inférieur de la console Google Cloud.
Définissez les variables d'environnement par défaut :
```
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_VERSION
```
Remplacez les valeurs suivantes :
- PROJECT_ID: votre Google Cloud ID de projet.
- CLUSTER_NAME : nom de votre cluster GKE.
- BUCKET_NAME : nom du bucket Cloud Storage. Vous n'avez pas besoin de spécifier le préfixe gs://.
- REGION : région où se trouvent le cluster GKE, le bucket Cloud Storage et les nœuds TPU. La région contient des zones où les types de machines TPU v5e sont disponibles (par exemple, us-west1, us-west4, us-central1, us-east1, us-east5 ou europe-west4). Pour les clusters Autopilot, assurez-vous de disposer de suffisamment de ressources zonales TPU v5e pour la région de votre choix.
- (Cluster standard uniquement) LOCATION : zone où les ressources TPU sont disponibles (par exemple, us-west4-a). Pour les clusters Autopilot, il n'est pas nécessaire de spécifier la zone, mais uniquement la région.
- CLUSTER_VERSION : version de GKE, qui doit être compatible avec le type de machine que vous souhaitez utiliser. Notez que la version de GKE par défaut peut ne pas avoir de disponibilité pour votre TPU cible. Pour obtenir la liste des versions minimales de GKE disponibles par type de machine TPU, consultez la page Disponibilité des TPU dans GKE.

Créer et configurer des ressources Google Cloud

Suivez les instructions ci-dessous pour créer les ressources requises.

Créer un cluster GKE

Vous pouvez diffuser les modèles Gemma sur des TPU dans un cluster GKE Autopilot ou GKE Standard. Nous vous recommandons d'utiliser un cluster GKE Autopilot pour une expérience Kubernetes entièrement gérée. Pour choisir le mode de fonctionnement GKE le mieux adapté à vos charges de travail, consultez la section Choisir un mode de fonctionnement GKE.

Autopilot

Créez un cluster GKE Autopilot :

gcloud container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --region=REGION \
    --cluster-version=CLUSTER_VERSION

Standard

Créez un cluster GKE Standard régional qui utilise la fédération d'identité de charge de travail pour 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 création du cluster peut prendre plusieurs minutes.

Créez un pool de nœuds TPU v5e avec une topologie 2x4 et deux nœuds :

gcloud container node-pools create tpu-nodepool \
  --cluster=CLUSTER_NAME \
  --machine-type=ct5lp-hightpu-8t \
  --project=PROJECT_ID \
  --num-nodes=2 \
  --region=REGION \
  --node-locations=LOCATION

Créer un bucket Cloud Storage

Créez un bucket Cloud Storage pour stocker le point de contrôle converti:

gcloud storage buckets create gs://BUCKET_NAME --location=REGION

Générer votre jeton de CLI Hugging Face dans Cloud Shell

Générez un nouveau jeton Hugging Face si vous n'en possédez pas déjà un :

Cliquez sur Your Profile > Settings > Access Tokens (Votre profil > Paramètres > Jetons d'accès).
Cliquez sur Nouveau jeton.
Spécifiez le nom de votre choix et un rôle d'au moins Read.
Cliquez sur Generate a token (Générer un jeton).
Modifiez les autorisations de votre jeton d'accès pour disposer d'un accès en lecture au dépôt Hugging Face de votre modèle.
Copiez le jeton dans votre presse-papiers.

Créer un secret Kubernetes pour les identifiants Hugging Face

Dans Cloud Shell, procédez comme suit :

Configurez kubectl de manière à communiquer avec votre cluster :

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

Créez un Secret pour stocker les identifiants Hugging Face :
```
kubectl create secret generic huggingface-secret \
    --from-literal=HUGGINGFACE_TOKEN=HUGGINGFACE_TOKEN
```
Remplacez HUGGINGFACE_TOKEN par votre jeton Hugging Face.

Configurer l'accès à vos charges de travail à l'aide de la fédération d'identité de charge de travail pour GKE

Attribuez un compte de service Kubernetes à l'application et configurez ce compte de service Kubernetes pour qu'il agisse en tant que compte de service IAM.

Créez un compte de service IAM pour votre application :
```
gcloud iam service-accounts create wi-jetstream
```

Ajoutez une liaison de stratégie IAM pour votre compte de service IAM afin de gérer 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.insightsCollectorService

Autorisez le compte de service Kubernetes à emprunter l'identité du compte de service IAM en ajoutant une liaison de stratégie IAM entre les deux comptes de service. Cette liaison permet au compte de service Kubernetes d'agir en tant que compte de service 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]"
```

Annotez le compte de service Kubernetes avec l'adresse e-mail du compte de service IAM.

kubectl annotate serviceaccount default \
    iam.gke.io/gcp-service-account=wi-jetstream@PROJECT_ID.iam.gserviceaccount.com

Déployer JetStream

Déployez le conteneur JetStream pour diffuser votre modèle. Ce tutoriel utilise des fichiers manifestes de déploiement Kubernetes. Un déploiement est un objet d'API Kubernetes qui vous permet d'exécuter plusieurs réplicas de pods répartis entre les nœuds d'un cluster.

Enregistrez le manifeste suivant sous le nom jetstream-pytorch-deployment.yaml :

Gemma 7B-it

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jetstream-pytorch-server
spec:
  replicas: 2
  selector:
    matchLabels:
      app: jetstream-pytorch-server
  template:
    metadata:
      labels:
        app: jetstream-pytorch-server
      annotations:
        gke-gcsfuse/volumes: "true"
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      containers:
      - name: jetstream-pytorch-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-pytorch-server:v0.2.4
        args:
        - --model_id=google/gemma-7b-it
        - --override_batch_size=30
        - --working_dir=/models/pytorch/
        - --enable_model_warmup=True
        volumeMounts:
        - name: gcs-fuse-checkpoint
          mountPath: /models
        - name: huggingface-credentials
          mountPath: /huggingface
          readOnly: true
        ports:
        - containerPort: 9000
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
        startupProbe:
          httpGet:
            path: /healthcheck
            port: 8000
            scheme: HTTP
          periodSeconds: 60
          initialDelaySeconds: 90
          failureThreshold: 50
        livenessProbe:
          httpGet:
            path: /healthcheck
            port: 8000
            scheme: HTTP
          periodSeconds: 60
          failureThreshold: 30
        readinessProbe:
          httpGet:
            path: /healthcheck
            port: 8000
            scheme: HTTP
          periodSeconds: 60
          failureThreshold: 30
      - name: jetstream-http
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.3
        ports:
        - containerPort: 8000
      volumes:
      - name: huggingface-credentials
        secret:
          defaultMode: 0400
          secretName: huggingface-secret
      - name: gke-gcsfuse-cache
        emptyDir:
          medium: Memory
      - name: gcs-fuse-checkpoint
        csi:
          driver: gcsfuse.csi.storage.gke.io
          volumeAttributes:
            bucketName: BUCKET_NAME
            mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
---
apiVersion: v1
kind: Service
metadata:
  name: jetstream-svc
spec:
  selector:
    app: jetstream-pytorch-server
  ports:
  - protocol: TCP
    name: jetstream-http
    port: 8000
    targetPort: 8000

Llama 3 8B

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jetstream-pytorch-server
spec:
  replicas: 2
  selector:
    matchLabels:
      app: jetstream-pytorch-server
  template:
    metadata:
      labels:
        app: jetstream-pytorch-server
      annotations:
        gke-gcsfuse/volumes: "true"
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      containers:
      - name: jetstream-pytorch-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-pytorch-server:v0.2.4
        args:
        - --model_id=meta-llama/Meta-Llama-3-8B
        - --override_batch_size=30
        - --working_dir=/models/pytorch/
        - --enable_model_warmup=True
        volumeMounts:
        - name: gcs-fuse-checkpoint
          mountPath: /models
        - name: huggingface-credentials
          mountPath: /huggingface
          readOnly: true
        ports:
        - containerPort: 9000
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
        startupProbe:
          httpGet:
            path: /healthcheck
            port: 8000
            scheme: HTTP
          periodSeconds: 60
          initialDelaySeconds: 90
          failureThreshold: 50
        livenessProbe:
          httpGet:
            path: /healthcheck
            port: 8000
            scheme: HTTP
          periodSeconds: 60
          failureThreshold: 30
        readinessProbe:
          httpGet:
            path: /healthcheck
            port: 8000
            scheme: HTTP
          periodSeconds: 60
          failureThreshold: 30
      - name: jetstream-http
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.3
        ports:
        - containerPort: 8000
      volumes:
      - name: huggingface-credentials
        secret:
          defaultMode: 0400
          secretName: huggingface-secret
      - name: gke-gcsfuse-cache
        emptyDir:
          medium: Memory
      - name: gcs-fuse-checkpoint
        csi:
          driver: gcsfuse.csi.storage.gke.io
          volumeAttributes:
            bucketName: BUCKET_NAME
            mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
---
apiVersion: v1
kind: Service
metadata:
  name: jetstream-svc
spec:
  selector:
    app: jetstream-pytorch-server
  ports:
  - protocol: TCP
    name: jetstream-http
    port: 8000
    targetPort: 8000

Le fichier manifeste définit les propriétés clés suivantes :

model_id: nom du modèle Hugging Face (google/gemma-7b-it, meta-llama/Meta-Llama-3-8B) (voir les modèles compatibles).
override_batch_size : taille du lot de décodage par appareil, où une puce TPU équivaut à un appareil Cette valeur est définie par défaut sur 30.
working_dir: répertoire de travail dans lequel le point de contrôle du modèle est ou sera stocké. Étant donné que le bucket Cloud Storage est installé sur votre nœud, votre charge de travail peut accéder aux points de contrôle à gs://BUCKET_NAME/pytorch/org/repo. Le serveur JetStream-PyTorch télécharge les pondérations du modèle à partir de Hugging Face dans le répertoire de travail lors de la première utilisation. Le chargement d'un modèle 7 ou 8 milliards prend quelques minutes. Pour les déploiements ultérieurs, le serveur JetStream-PyTorch charge les poids du modèle à partir du répertoire de travail, ce qui réduit le temps de chargement. Pour les points de contrôle préexistants, assurez-vous que le répertoire de travail utilise la même convention de chemin d'accès.
enable_model_warmup: ce paramètre active le préchauffage du modèle après le démarrage du serveur de modèle. Cette valeur est définie par défaut sur False.

Vous pouvez éventuellement définir les propriétés suivantes:

max_input_length: longueur maximale de la séquence d'entrée. Cette valeur est définie par défaut sur 1024.
max_output_length: longueur maximale de décodage de sortie. Cette valeur est définie par défaut sur 1024.
quantize_weights : si le point de contrôle est quantifié Cette valeur est définie par défaut sur 0. Définissez-la sur 1 pour activer la quantification int8.
internal_jax_compilation_cache: répertoire du cache de compilation JAX. Cette valeur est définie par défaut sur ~/jax_cache. Définissez-la sur gs://BUCKET_NAME/jax_cache pour la mise en cache à distance.

Dans le fichier manifeste, une vérification de démarrage est configurée pour s'assurer que le serveur de modèle est associé à l'étiquette Ready une fois le modèle chargé et l'échauffement terminé. Les vérifications d'activité et d'aptitude sont configurées pour garantir l'intégrité du serveur de modèle.

Remplacez BUCKET_NAME par votre GSBucket créé précédemment :

sed -i "s|BUCKET_NAME|BUCKET_NAME|g" jetstream-pytorch-deployment.yaml

Appliquez le fichier manifeste :

kubectl apply -f jetstream-pytorch-deployment.yaml

Vérifiez le déploiement :
```
kubectl get deployment
```
Le résultat ressemble à ce qui suit :
```
NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
jetstream-pytorch-server          0/2     2            0           ##s
```
Pour les clusters Autopilot, le provisionnement des ressources TPU requises peut prendre quelques minutes.
Affichez les journaux du serveur JetStream-PyTorch pour vérifier que les poids du modèle ont été chargés et que le préchauffage du modèle est terminé. Le serveur peut mettre quelques minutes à effectuer cette opération.
```
kubectl logs deploy/jetstream-pytorch-server -f -c jetstream-pytorch-server
```
Le résultat ressemble à ce qui suit :
```
Started jetstream_server....
2024-04-12 04:33:37,128 - root - INFO - ---------Generate params 0 loaded.---------
```

Vérifiez que le déploiement est prêt:

kubectl get deployment

Le résultat ressemble à ce qui suit :

NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
jetstream-pytorch-server          2/2     2            2           ##s

L'enregistrement du point de terminaison healthcheck peut prendre plusieurs minutes.

Diffuser le modèle

Dans cette section, vous allez interagir avec le modèle.

Configurer le transfert de port

Vous pouvez accéder au déploiement JetStream via le service ClusterIP que vous avez créé à l'étape précédente. Les services ClusterIP ne sont accessibles qu'à partir du cluster. Par conséquent, pour accéder au service en dehors du cluster, procédez comme suit :

Pour établir une session de transfert de port, exécutez la commande suivante :

kubectl port-forward svc/jetstream-svc 8000:8000

Interagir avec le modèle à l'aide de curl

Vérifiez que vous pouvez accéder au serveur HTTP JetStream en ouvrant un nouveau terminal et en exécutant la commande suivante :

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8000/generate \
--data \
'{
    "prompt": "What are the top 5 programming languages",
    "max_tokens": 200
}'

L'exécution de la requête initiale peut prendre plusieurs secondes en raison de l'échauffement du modèle. Le résultat ressemble à ce qui suit :

{
    "response": " for data science in 2023?\n\n**1. Python:**\n- Widely used for data science due to its readability, extensive libraries (pandas, scikit-learn), and integration with other tools.\n- High demand for Python programmers in data science roles.\n\n**2. R:**\n- Popular choice for data analysis and visualization, particularly in academia and research.\n- Extensive libraries for statistical modeling and data wrangling.\n\n**3. Java:**\n- Enterprise-grade platform for data science, with strong performance and scalability.\n- Widely used in data mining and big data analytics.\n\n**4. SQL:**\n- Essential for data querying and manipulation, especially in relational databases.\n- Used for data analysis and visualization in various industries.\n\n**5. Scala:**\n- Scalable and efficient for big data processing and machine learning models.\n- Popular in data science for its parallelism and integration with Spark and Spark MLlib."
}

Vous avez effectué les opérations suivantes:

Déploiement du serveur de modèle JetStream-PyTorch sur GKE à l'aide de TPU.
Un point de contrôle a été créé à gs://BUCKET_NAME/pytorch/org/repo.
Diffuser le modèle et interagir avec lui.

Résoudre les problèmes

Si le message Empty reply from server s'affiche, il est possible que le conteneur n'ait pas terminé le téléchargement des données du modèle. Vérifiez à nouveau dans les journaux du pod le message Connected indiquant que le modèle est prêt à être diffusé.
Si Connection refused s'affiche, vérifiez que le transfert de port est actif.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer les ressources déployées

Pour éviter que les ressources que vous avez créées dans ce guide ne soient facturées sur votre compte Google Cloud , exécutez les commandes suivantes et suivez les instructions:

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

Étape suivante

Découvrez comment exécuter des modèles Gemma sur GKE et comment exécuter des charges de travail d'IA ou de ML optimisées grâce aux fonctionnalités d'orchestration de plates-formes GKE.
Apprenez-en plus sur les TPU dans GKE.
Explorez le dépôt GitHub JetStream.
Explorez Vertex AI Model Garden.

Diffuser un LLM à l'aide de TPU sur GKE avec JetStream et PyTorch

Contexte

À propos des TPU

À propos de JetStream

À propos de PyTorch

Objectifs

Architecture

Avant de commencer

Check for the roles

Grant the roles

Accéder au modèle

Gemma 7B-it

Llama 3 8B

Préparer l'environnement

Créer et configurer des ressources Google Cloud

Créer un cluster GKE

Autopilot

Standard

Créer un bucket Cloud Storage

Générer votre jeton de CLI Hugging Face dans Cloud Shell

Créer un secret Kubernetes pour les identifiants Hugging Face

Configurer l'accès à vos charges de travail à l'aide de la fédération d'identité de charge de travail pour GKE

Déployer JetStream

Gemma 7B-it

Llama 3 8B

Diffuser le modèle

Configurer le transfert de port

Interagir avec le modèle à l'aide de curl

Résoudre les problèmes

Effectuer un nettoyage

Supprimer les ressources déployées

Étape suivante