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 :

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

Ce tutoriel couvre la diffusion de 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 des TPU PyTorch/XLA et JAX pour obtenir des performances optimales.

Traitement par lots continu

Le traitement par lots 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 de clés-valeurs consiste à compresser le cache de clés-valeurs 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, reportez-vous aux 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

  1. Préparer un cluster GKE Autopilot ou standard avec la topologie TPU recommandée en fonction des caractéristiques du modèle.
  2. Déployer les composants JetStream sur GKE.
  3. Obtenir et publier votre modèle.
  4. 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 du 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 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 vers 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 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.

      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.

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.

  1. Accédez à la page de consentement du modèle Gemma sur Hugging Face.
  2. Connectez-vous à Hugging Face si vous ne l'avez pas déjà fait.
  3. 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 de consentement de la licence.

  1. Accéder à la page d'autorisation du modèle Llama 3 sur Hugging Face
  2. Connectez-vous à Hugging Face si vous ne l'avez pas déjà fait.
  3. 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 sur Google 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 :

  1. Dans la console Google Cloud, lancez une session Cloud Shell en cliquant sur Icône d'activation Cloud Shell Activer Cloud Shell dans la console Google Cloud. Une session s'ouvre dans le volet inférieur de la console Google Cloud.

  2. 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 : ID de votre projet Google Cloud.
    • 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 les zones dans lesquelles 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 GKE par défaut n'est peut-être pas disponible 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

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

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

  1. Cliquez sur Your Profile > Settings > Access Tokens (Votre profil > Paramètres > Jetons d'accès).
  2. Cliquez sur Nouveau jeton.
  3. Spécifiez le nom de votre choix et un rôle d'au moins Read.
  4. Cliquez sur Generate a token (Générer un jeton).
  5. 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.
  6. Copiez le jeton dans votre presse-papiers.

Créer un secret Kubernetes pour les identifiants Hugging Face

Dans Cloud Shell, procédez comme suit :

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

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

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

  1. Créez un compte de service IAM pour votre application :

    gcloud iam service-accounts create wi-jetstream

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

  3. 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]"

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

Convertir les points de contrôle du modèle

Dans cette section, vous allez créer un Job pour effectuer les opérations suivantes :

  1. Télécharger le point de contrôle de base de Hugging Face dans le répertoire local
  2. Convertir le point de contrôle en point de contrôle compatible JetStream-Pytorch
  3. Importer le point de contrôle dans un bucket Cloud Storage

Déployer la tâche de conversion du point de contrôle du modèle

Gemma 7B-it

Téléchargez et convertissez les fichiers de point de contrôle du modèle Gemma 7B :

  1. Enregistrez le manifeste suivant sous le nom job-checkpoint-converter.yaml :

    apiVersion: batch/v1
kind: Job
metadata:
  name: checkpoint-converter
spec:
  ttlSecondsAfterFinished: 30
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: inference-checkpoint
        image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.3
        args:
        - -s=jetstream-pytorch
        - -m=google/gemma-7b-it-pytorch
        - -o=gs://BUCKET_NAME/pytorch/gemma-7b-it/final/bf16/
        - -n=gemma
        - -q=False
        - -h=True
        volumeMounts:
        - mountPath: "/huggingface/"
          name: huggingface-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: huggingface-credentials
        secret:
          defaultMode: 0400
          secretName: huggingface-secret

Llama 3 8B

Téléchargez et convertissez les fichiers de point de contrôle du modèle Llama 3 8B :

  1. Enregistrez le manifeste suivant sous le nom job-checkpoint-converter.yaml :

    apiVersion: batch/v1
kind: Job
metadata:
  name: checkpoint-converter
spec:
  ttlSecondsAfterFinished: 30
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: inference-checkpoint
        image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.3
        args:
        - -s=jetstream-pytorch
        - -m=meta-llama/Meta-Llama-3-8B
        - -o=gs://BUCKET_NAME/pytorch/llama-3-8b/final/bf16/
        - -n=llama-3
        - -q=False
        - -h=True
        volumeMounts:
        - mountPath: "/huggingface/"
          name: huggingface-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: huggingface-credentials
        secret:
          defaultMode: 0400
          secretName: huggingface-secret

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

    sed -i "s|BUCKET_NAME|BUCKET_NAME|g" job-checkpoint-converter.yaml

  2. Appliquez le fichier manifeste :

    kubectl apply -f job-checkpoint-converter.yaml

  3. Attendez que le pod planifiant le Job commence à s'exécuter :

    kubectl get pod -w

    Le résultat ressemble à ce qui suit. Cela peut prendre quelques minutes :

    NAME                        READY   STATUS              RESTARTS   AGE
checkpoint-converter-abcd   0/1     ContainerCreating   0          28s
checkpoint-converter-abcd   1/1     Running             0          51s

    Pour les clusters Autopilot, le provisionnement des ressources TPU requises peut prendre quelques minutes.

  4. Vérifiez que le Job est terminé en affichant les journaux associés :

    kubectl logs -f jobs/checkpoint-converter

    Une fois la tâche terminée, le résultat ressemble à ce qui suit :

    Completed uploading converted checkpoint from local path /pt-ckpt/ to GSBucket gs://BUCKET_NAME/pytorch/<model_name>/final/bf16/"

Déployer JetStream

Déployez le conteneur JetStream pour diffuser votre modèle :

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.3
        args:
        - --size=7b
        - --model_name=gemma
        - --batch_size=32
        - --max_cache_length=2048
        - --quantize_weights=False
        - --quantize_kv_cache=False
        - --tokenizer_path=/models/pytorch/gemma-7b-it/final/bf16/tokenizer.model
        - --checkpoint_path=/models/pytorch/gemma-7b-it/final/bf16/model.safetensors
        ports:
        - containerPort: 9000
        volumeMounts:
        - name: gcs-fuse-checkpoint
          mountPath: /models
          readOnly: true
        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
      volumes:
      - name: gcs-fuse-checkpoint
        csi:
          driver: gcsfuse.csi.storage.gke.io
          readOnly: true
          volumeAttributes:
            bucketName: BUCKET_NAME
            mountOptions: "implicit-dirs"
---
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.3
        args:
        - --size=8b
        - --model_name=llama-3
        - --batch_size=32
        - --max_cache_length=2048
        - --quantize_weights=False
        - --quantize_kv_cache=False
        - --tokenizer_path=/models/pytorch/llama-3-8b/final/bf16/tokenizer.model
        - --checkpoint_path=/models/pytorch/llama-3-8b/final/bf16/model.safetensors
        ports:
        - containerPort: 9000
        volumeMounts:
        - name: gcs-fuse-checkpoint
          mountPath: /models
          readOnly: true
        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
      volumes:
      - name: gcs-fuse-checkpoint
        csi:
          driver: gcsfuse.csi.storage.gke.io
          readOnly: true
          volumeAttributes:
            bucketName: BUCKET_NAME
            mountOptions: "implicit-dirs"
---
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 :

  • size : taille de votre modèle
  • model_name : nom du modèle (gemma, llama-3)
  • batch_size : taille du lot de décodage par appareil, où une puce TPU équivaut à un appareil
  • max_cache_length : longueur maximale du cache kv
  • quantize_weights : si le point de contrôle est quantifié
  • quantize_kv_cache : si le cache kv est quantifié
  • tokenizer_path : chemin d'accès au fichier de tokenisation du modèle
  • checkpoint_path : chemin d'accès au point de contrôle

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

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

  2. Appliquez le fichier manifeste :

    kubectl apply -f jetstream-pytorch-deployment.yaml

  3. 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          2/2     2            2           ##s

    Pour les clusters Autopilot, le provisionnement des ressources TPU requises peut prendre quelques minutes.

  4. Consultez les journaux du serveur HTTP pour vérifier que le modèle a été chargé et compilé. Le serveur peut prendre quelques minutes pour effectuer cette opération.

    kubectl logs deploy/jetstream-pytorch-server -f -c jetstream-http

    Le résultat ressemble à ce qui suit :

    kubectl logs deploy/jetstream-pytorch-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)

  5. Affichez les journaux du serveur JetStream-PyTorch et vérifiez que la compilation est terminée :

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

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

  1. 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."
}

Résoudre les problèmes

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

Étapes suivantes