Déployer et diffuser des modèles Llama 2 sur TPU v5e à l'aide de SAX

Ce tutoriel vous guide à travers :

  • Créer une VM Cloud TPU pour déployer la famille de grands modèles de langage (LLM) Llama 2, disponible en différentes tailles (70, 13 ou 70 milliards)
  • Préparer des points de contrôle pour les modèles et les déployer sur SAX
  • Interagir avec le modèle via un point de terminaison HTTP

La diffusion pour les tests AGI (SAX) est un système expérimental qui diffuse les modèles Paxml, JAX et PyTorch pour l'inférence. Le code et la documentation de SAX se trouvent dans le dépôt Git Saxml. La version stable actuelle compatible avec TPU v5e est la v1.1.0.

À propos des cellules SAX

Une cellule (ou cluster) SAX est l'unité principale pour la diffusion de vos modèles. Il se compose de deux éléments principaux:

  • Serveur d'administration: ce serveur assure le suivi de vos serveurs de modèles, leur attribue des modèles et aide les clients à trouver le bon serveur de modèles avec lequel interagir.
  • Serveurs de modèles: ces serveurs exécutent votre modèle. Ils sont chargés de traiter les requêtes entrantes et de générer les réponses.

Le schéma suivant montre le diagramme d'une cellule SAX:

Cellule SAX avec serveur d'administration et serveurs de modèles

Figure 1 : Cellule SAX avec serveur d'administration et serveur de modèles.

Vous pouvez interagir avec une cellule SAX à l'aide de clients écrits en Python, C++ ou Go, ou directement via un serveur HTTP. Le schéma suivant montre comment un client externe peut interagir avec une cellule SAX:

Un client externe et un point de terminaison HTTP interagissant avec une cellule SAX

Figure 2. Architecture d'exécution d'un client externe interagissant avec une cellule SAX.

Objectifs

  • Configurer des ressources TPU pour la diffusion
  • Créer un cluster SAX
  • Publier le modèle Llama 2
  • Interagir avec le modèle

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

  • Cloud TPU
  • Compute Engine
  • Cloud Storage

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

Configurez votre projet Google Cloud, activez l'API Cloud TPU et créez un compte de service en suivant les instructions de la section Configurer l'environnement Cloud TPU.

Créer un TPU

Les étapes suivantes expliquent comment créer une VM TPU qui diffusera votre modèle.

  1. Créez des variables d'environnement :

    export PROJECT_ID=PROJECT_ID
export ACCELERATOR_TYPE=ACCELERATOR_TYPE
export ZONE=ZONE
export RUNTIME_VERSION=v2-alpha-tpuv5-lite
export SERVICE_ACCOUNT=SERVICE_ACCOUNT
export TPU_NAME=TPU_NAME
export QUEUED_RESOURCE_ID=QUEUED_RESOURCE_ID

    Description des variables d'environnement

    PROJECT_ID
    ID de votre projet Google Cloud.
    ACCELERATOR_TYPE
    Le type d'accélérateur spécifie la version et la taille de la ressource Cloud TPU que vous souhaitez créer. Les différentes tailles de modèle Llama 2 ont des exigences différentes en termes de taille de TPU :
    • 7B: v5litepod-4 ou supérieur
    • 13B: v5litepod-8 ou supérieur
    • 70B: v5litepod-16 ou plus
    ZONE
    Zone dans laquelle vous souhaitez créer votre Cloud TPU.
    SERVICE_ACCOUNT
    Compte de service que vous souhaitez associer à votre Cloud TPU.
    TPU_NAME
    Nom de votre Cloud TPU.
    QUEUED_RESOURCE_ID
    Identifiant de votre requête de ressource en file d'attente.

  2. Définissez l'ID et la zone du projet dans votre configuration active de la Google Cloud CLI:

    gcloud config set project $PROJECT_ID  && gcloud config set compute/zone $ZONE

  3. Créez la VM TPU:

    gcloud compute tpus queued-resources create ${QUEUED_RESOURCE_ID} \
  --node-id ${TPU_NAME} \
  --project ${PROJECT_ID} \
  --zone ${ZONE} \
  --accelerator-type ${ACCELERATOR_TYPE} \
  --runtime-version ${RUNTIME_VERSION} \
  --service-account ${SERVICE_ACCOUNT}

  4. Vérifiez que le TPU est actif:

    gcloud compute tpus queued-resources list --project $PROJECT_ID --zone $ZONE

Configurer le nœud de conversion de point de contrôle

Pour exécuter les modèles LLama sur un cluster SAX, vous devez convertir les points de contrôle Llama d'origine dans un format compatible SAX.

La conversion nécessite d'importantes ressources de mémoire, selon la taille du modèle:

Modèle Type de machine
7 Mrds 50-60 Go de mémoire
13 Mrds 120 Go de mémoire
70 Mrds 500 à 600 Go de mémoire (type de machine N2 ou M1)

Pour les modèles 7B et 13B, vous pouvez exécuter la conversion sur la VM TPU. Pour le modèle 70 milliards, vous devez créer une instance Compute Engine avec environ 1 To d'espace disque:

gcloud compute instances create INSTANCE_NAME --project=$PROJECT_ID --zone=$ZONE \
  --machine-type=n2-highmem-128 \
  --network-interface=network-tier=PREMIUM,stack-type=IPV4_ONLY,subnet=default \
  --maintenance-policy=MIGRATE --provisioning-model=STANDARD \
  --service-account=$SERVICE_ACCOUNT \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=http-server,https-server \
  --create-disk=auto-delete=yes,boot=yes,device-name=bk-workday-dlvm,image=projects/ml-images/global/images/c0-deeplearning-common-cpu-v20230925-debian-10,mode=rw,size=500,type=projects/$PROJECT_ID/zones/$ZONE/diskTypes/pd-balanced \
  --no-shielded-secure-boot \
  --shielded-vtpm \
  --shielded-integrity-monitoring \
  --labels=goog-ec-src=vm_add-gcloud \
  --reservation-affinity=any

Que vous utilisiez une instance TPU ou Compute Engine comme serveur de conversion, configurez votre serveur pour convertir les points de contrôle Llama 2:

  1. Pour les modèles 7B et 13B, définissez la variable d'environnement de nom de serveur sur le nom de votre TPU:

    export CONV_SERVER_NAME=$TPU_NAME

    Pour le modèle 70B, définissez la variable d'environnement de nom de serveur sur le nom de votre instance Compute Engine:

    export CONV_SERVER_NAME=INSTANCE_NAME

  2. Connectez-vous au nœud de conversion à l'aide de SSH.

    Si votre nœud de conversion est un TPU, connectez-vous au TPU:

    gcloud compute tpus tpu-vm ssh $CONV_SERVER_NAME --project=$PROJECT_ID --zone=$ZONE

    Si votre nœud de conversion est une instance Compute Engine, connectez-vous à la VM Compute Engine:

    gcloud compute ssh $CONV_SERVER_NAME --project=$PROJECT_ID --zone=$ZONE

  3. Installez les packages requis sur le nœud de conversion:

    sudo apt update
sudo apt-get install python3-pip
sudo apt-get install git-all

pip3 install paxml==1.1.0
pip3 install torch
pip3 install jaxlib==0.4.14

  4. Téléchargez le script de conversion du point de contrôle Llama:

    gcloud storage cp gs://cloud-tpu-inference-public/sax-tokenizers/llama/convert_llama_ckpt.py .

Télécharger les poids Llama 2

Avant de convertir le modèle, vous devez télécharger les pondérations Llama 2. Pour ce tutoriel, vous devez utiliser les pondérations Llama 2 d'origine (par exemple, meta-llama/Llama-2-7b) et non celles qui ont été converties pour le format Hugging Face Transformers (par exemple, meta-llama/Llama-2-7b-hf).

Si vous disposez déjà des pondérations Llama 2, passez directement à la section Convertir les pondérations.

Pour télécharger les poids à partir du hub Hugging Face, vous devez configurer un jeton d'accès utilisateur et demander l'accès aux modèles Llama 2. Pour demander l'accès, suivez les instructions de la page Hugging Face du modèle que vous souhaitez utiliser, par exemple meta-llama/Llama-2-7b.

  1. Créez un répertoire pour les pondérations:

    sudo mkdir WEIGHTS_DIRECTORY

  2. Obtenez les poids Llama2 depuis le hub Hugging Face:

    1. Installez la CLI du hub Hugging Face:

      pip install -U "huggingface_hub[cli]"

    2. Accédez au répertoire des pondérations:

      cd WEIGHTS_DIRECTORY

    3. Téléchargez les fichiers Llama 2:

      python3
from huggingface_hub import login
login()
from huggingface_hub import hf_hub_download, snapshot_download
import os
PATH=os.getcwd()
snapshot_download(repo_id="meta-llama/LLAMA2_REPO", local_dir_use_symlinks=False, local_dir=PATH)

      Remplacez LLAMA2_REPO par le nom du dépôt Hugging Face à partir duquel vous souhaitez effectuer le téléchargement: Llama-2-7b, Llama-2-13b ou Llama-2-70b.

Convertir les pondérations

Modifiez le script de conversion, puis exécutez-le pour convertir les pondérations du modèle.

  1. Créez un répertoire pour stocker les pondérations converties:

    sudo mkdir CONVERTED_WEIGHTS

  2. Clonez le dépôt GitHub Saxml dans un répertoire où vous disposez des autorisations de lecture, d'écriture et d'exécution:

      git clone https://github.com/google/saxml.git -b r1.1.0

  3. Accédez au répertoire saxml :

    cd saxml

  4. Ouvrez le fichier saxml/tools/convert_llama_ckpt.py.

  5. Dans le fichier saxml/tools/convert_llama_ckpt.py, remplacez la ligne 169:

    'scale': pytorch_vars[0]['layers.%d.attention_norm.weight' % (layer_idx)].type(torch.float16).numpy()

    À :

    'scale': pytorch_vars[0]['norm.weight'].type(torch.float16).numpy()

  6. Exécutez le script saxml/tools/init_cloud_vm.sh :

    saxml/tools/init_cloud_vm.sh

  7. Pour 70B uniquement: pour désactiver le mode de test, procédez comme suit:

    1. Ouvrez le fichier saxml/server/pax/lm/params/lm_cloud.py.

    2. Dans le fichier saxml/server/pax/lm/params/lm_cloud.py, remplacez la ligne 344:

      return True

      À :

      return False

  8. Convertissez les pondérations:

    python3 saxml/tools/convert_llama_ckpt.py --base-model-path WEIGHTS_DIRECTORY \
  --pax-model-path CONVERTED_WEIGHTS \
  --model-size MODEL_SIZE

    Remplacez les éléments suivants :

    • WEIGHTS_DIRECTORY: répertoire des pondérations d'origine.
    • CONVERTED_WEIGHTS: chemin cible pour les pondérations converties.
    • MODEL_SIZE : 7b, 13b ou 70b.

Préparer le répertoire du point de contrôle

Une fois les points de contrôle convertis, leur répertoire doit présenter la structure suivante:

checkpoint_00000000
  metadata/
      metadata
    state/
        mdl_vars.params.lm*/
        ...
        ...
        step/

Créez un fichier vide nommé commit_success.txt et placez-en une copie dans les répertoires checkpoint_00000000, metadata et state. Cela indique à SAX que ce point de contrôle est entièrement converti et prêt à être chargé:

  1. Accédez au répertoire du point de contrôle:

    cd CONVERTED_WEIGHTS/checkpoint_00000000

  2. Créez un fichier vide nommé commit_success.txt :

    touch commit_success.txt

  3. Accédez au répertoire des métadonnées et créez un fichier vide nommé commit_success.txt:

    cd metadata && touch commit_success.txt

  4. Accédez au répertoire d'état et créez un fichier vide nommé commit_success.txt:

    cd .. && cd state && touch commit_success.txt

Le répertoire du point de contrôle doit maintenant présenter la structure suivante:

checkpoint_00000000
    commit_success.txt
metadata/
    commit_success.txt
    metadata
    state/
        commit_success.txt
        mdl_vars.params.lm*/
        ...
        ...
        step/

Créer un bucket Cloud Storage

Vous devez stocker les points de contrôle convertis dans un bucket Cloud Storage afin qu'ils soient disponibles lors de la publication du modèle.

  1. Définissez une variable d'environnement pour le nom de votre bucket Cloud Storage:

    export GSBUCKET=BUCKET_NAME

  2. Créez un bucket:

    gcloud storage buckets create gs://${GSBUCKET}

  3. Copiez vos fichiers de point de contrôle convertis dans votre bucket:

    gcloud storage cp -r CONVERTED_WEIGHTS/checkpoint_00000000  gs://$GSBUCKET/sax_models/llama2/SAX_LLAMA2_DIR/

    Remplacez SAX_LLAMA2_DIR par la valeur appropriée:

    • 7B: saxml_llama27b
    • 13B: saxml_llama213b
    • 70B: saxml_llama270b

Créer un cluster SAX

Pour créer un cluster SAX, vous devez:

Dans un déploiement type, vous exécutez le serveur d'administration sur une instance Compute Engine et le serveur de modèles sur un TPU ou un GPU. Pour les besoins de ce tutoriel, vous allez déployer le serveur d'administration et le serveur de modèles sur la même instance TPU v5e.

Créer un serveur d'administration

Créez le conteneur Docker du serveur d'administration:

  1. Sur le serveur de conversion, installez Docker:

    sudo apt-get update
sudo apt-get install docker.io

  2. Lancez le conteneur Docker du serveur d'administration:

    sudo docker run --name sax-admin-server \
  -it \
  -d \
  --rm \
  --network host \
  --env GSBUCKET=${GSBUCKET} us-docker.pkg.dev/cloud-tpu-images/inference/sax-admin-server:v1.1.0

Vous pouvez exécuter la commande docker run sans l'option -d pour afficher les journaux et vous assurer que le serveur d'administration démarre correctement.

Créer un serveur de modèles

Les sections suivantes expliquent comment créer un serveur de modèles.

Modèle 7b

Lancez le conteneur Docker du serveur de modèles:

sudo docker run --privileged \
  -it \
  -d \
  --rm \
  --network host \
  --name "sax-model-server" \
  --env SAX_ROOT=gs://${GSBUCKET}/sax-root us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.1.0 \
  --sax_cell="/sax/test" \
  --port=10001 \
  --platform_chip=tpuv5e \
  --platform_topology='4'

Modèle 13b

Il manque la configuration de LLaMA13BFP16TPUv5e dans lm_cloud.py. Les étapes suivantes montrent comment mettre à jour lm_cloud.py et valider une nouvelle image Docker.

  1. Démarrez le serveur de modèles:

    sudo docker run --privileged \
  -it \
  -d \
  --rm \
  --network host \
  --name "sax-model-server" \
  --env SAX_ROOT=gs://${GSBUCKET}/sax-root \
  us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.1.0 \
  --sax_cell="/sax/test" \
  --port=10001 \
  --platform_chip=tpuv5e \
  --platform_topology='8'

  2. Connectez-vous au conteneur Docker à l'aide de SSH:

    sudo docker exec -it sax-model-server bash

  3. Installez Vim dans l'image Docker:

    $ apt update
$ apt install vim

  4. Ouvrez le fichier saxml/server/pax/lm/params/lm_cloud.py. Recherchez LLaMA13B. Le code suivant doit s'afficher:

    @servable_model_registry.register
@quantization.for_transformer(quantize_on_the_fly=False)
class LLaMA13B(BaseLLaMA):
  """13B model on a A100-40GB.

  April 12, 2023
  Latency = 5.06s with 128 decoded tokens. 38ms per output token.
  """

  NUM_LAYERS = 40
  VOCAB_SIZE = 32000
  DIMS_PER_HEAD = 128
  NUM_HEADS = 40
  MODEL_DIMS = 5120
  HIDDEN_DIMS = 13824
  ICI_MESH_SHAPE = [1, 1, 1]

  @property
  def test_mode(self) -> bool:
    return True

  5. Ajoutez un commentaire ou supprimez la ligne commençant par @quantization. Après cette modification, le fichier doit se présenter comme suit:

    @servable_model_registry.register
class LLaMA13B(BaseLLaMA):
  """13B model on a A100-40GB.

  April 12, 2023
  Latency = 5.06s with 128 decoded tokens. 38ms per output token.
  """

  NUM_LAYERS = 40
  VOCAB_SIZE = 32000
  DIMS_PER_HEAD = 128
  NUM_HEADS = 40
  MODEL_DIMS = 5120
  HIDDEN_DIMS = 13824
  ICI_MESH_SHAPE = [1, 1, 1]

  @property
  def test_mode(self) -> bool:
    return True

  6. Ajoutez le code suivant pour prendre en charge la configuration du TPU.

    @servable_model_registry.register
class LLaMA13BFP16TPUv5e(LLaMA13B):
"""13B model on TPU v5e-8.

"""

BATCH_SIZE = [1]
BUCKET_KEYS = [128]
MAX_DECODE_STEPS = [32]
ENABLE_GENERATE_STREAM = False

ICI_MESH_SHAPE = [1, 1, 8]

@property
def test_mode(self) -> bool:
  return False

  7. Quittez la session SSH du conteneur Docker:

    exit

  8. Validez les modifications dans une nouvelle image Docker:

    sudo docker commit sax-model-server sax-model-server:v1.1.0-mod

  9. Vérifiez que l'image Docker a bien été créée:

    sudo docker images

    Vous pouvez publier l'image Docker dans Artifact Registry de votre projet, mais ce tutoriel porte sur l'image locale.

  10. Arrêtez le serveur de modèles. Le reste du tutoriel utilisera le serveur de modèle mis à jour.

    sudo docker stop sax-model-server

  11. Démarrez le serveur de modèles à l'aide de l'image Docker mise à jour. Veillez à spécifier le nouveau nom de l'image, sax-model-server:v1.1.0-mod:

    sudo docker run --privileged \
  -it \
  -d \
  --rm \
  --network host \
  --name "sax-model-server" \
  --env SAX_ROOT=gs://${GSBUCKET}/sax-root \
  sax-model-server:v1.1.0-mod \
  --sax_cell="/sax/test" \
  --port=10001 \
  --platform_chip=tpuv5e \
  --platform_topology='8'

Modèle 70B

Connectez-vous à votre TPU via SSH et démarrez le serveur de modèles:

gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
 --project ${PROJECT_ID} \
 --zone ${ZONE} \
 --worker=all \
 --command="
   gcloud auth configure-docker \
     us-docker.pkg.dev
   # Pull SAX model server image
   sudo docker pull us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.1.0
   # Run model server
   sudo docker run \
     --privileged  \
     -it \
     -d \
     --rm \
     --network host \
     --name "sax-model-server"  \
     --env SAX_ROOT=gs://${GSBUCKET}/sax-root \
     us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.1.0 \
     --sax_cell="/sax/test" \
     --port=10001 \
     --platform_chip=tpuv5e \
     --platform_topology='16'
"

Vérifier les journaux

Vérifiez les journaux du serveur de modèles pour vous assurer que celui-ci a démarré correctement:

docker logs -f sax-model-server

Si le serveur de modèles n'a pas démarré, consultez la section Dépannage pour en savoir plus.

Pour le modèle 70B, répétez ces étapes pour chaque VM TPU:

  1. Connectez-vous au TPU à l'aide de SSH:

    gcloud compute tpus tpu-vm ssh ${TPU_NAME} \
  --project ${PROJECT_ID} \
  --zone ${ZONE} \
  --worker=WORKER_NUMBER

    WORKER_NUMBER est un index basé sur 0 qui indique à quelle VM TPU vous souhaitez vous connecter.

  2. Vérifiez les journaux :

    sudo docker logs -f sax-model-server

    Trois VM TPU doivent indiquer qu'elles se sont connectées aux autres instances:

    I1117 00:16:07.196594 140613973207936 multi_host_sync.py:152] Received SPMD peer address 10.182.0.3:10001
I1117 00:16:07.197484 140613973207936 multi_host_sync.py:152] Received SPMD peer address 10.182.0.87:10001
I1117 00:16:07.199437 140613973207936 multi_host_sync.py:152] Received SPMD peer address 10.182.0.13:10001

    L'une des VM TPU doit comporter des journaux indiquant le démarrage du serveur de modèle:

    I1115 04:01:29.479170 139974275995200 model_service_base.py:867] Started joining SAX cell /sax/test
ERROR: logging before flag.Parse: I1115 04:01:31.479794       1 location.go:141] Calling Join due to address update
ERROR: logging before flag.Parse: I1115 04:01:31.814721       1 location.go:155] Joined 10.182.0.44:10000

Publier le modèle

SAX est fourni avec un outil de ligne de commande appelé saxutil, qui simplifie les interactions avec les serveurs de modèles SAX. Dans ce tutoriel, vous utilisez saxutil pour publier le modèle. Pour obtenir la liste complète des commandes saxutil, consultez le fichier README Saxml.

  1. Accédez au répertoire dans lequel vous avez cloné le dépôt GitHub Saxml:

    cd  saxml

  2. Pour le modèle 70 milliards, connectez-vous à votre serveur de conversion:

    gcloud compute ssh ${CONV_SERVER_NAME} \
  --project ${PROJECT_ID} \
  --zone ${ZONE}

  3. Installez Bazel:

    sudo apt-get install bazel

  4. Définissez un alias pour exécuter saxutil avec votre bucket Cloud Storage:

    alias saxutil='bazel run saxml/bin:saxutil -- --sax_root=gs://${GSBUCKET}/sax-root'

  5. Publiez le modèle à l'aide de saxutil. Cette opération prend environ 10 minutes sur un TPU v5litepod-8.

    saxutil --sax_root=gs://${GSBUCKET}/sax-root publish '/sax/test/MODEL' \
    saxml.server.pax.lm.params.lm_cloud.PARAMETERS \
    gs://${GSBUCKET}/sax_models/llama2/SAX_LLAMA2_DIR/checkpoint_00000000/ \
    1

    Remplacez les variables suivantes :

    Taille du modèle Valeurs
    7 Mrds MODEL: llama27b
    PARAMETERS: saxml.server.pax.lm.params.lm_cloud.LLaMA7BFP16TPUv5e
    SAX_LLAMA2_DIR: saxml_llama27b
    13 Mrds MODEL: llama213b
    PARAMETERS: saxml.server.pax.lm.params.lm_cloud.LLaMA13BFP16TPUv5e
    SAX_LLAMA2_DIR: saxml_llama213b
    70 Mrds MODEL: llama270b
    PARAMETERS: saxml.server.pax.lm.params.lm_cloud.LLaMA70BFP16TPUv5e
    SAX_LLAMA2_DIR: saxml_llama270b

Tester le déploiement

Pour vérifier si le déploiement a réussi, exécutez la commande saxutil ls:

saxutil ls /sax/test/MODEL

Un déploiement réussi doit présenter un nombre d'instances répliquées supérieur à zéro et se présenter comme suit:

INFO: Running command line: bazel-bin/saxml/bin/saxutil_/saxutil '--sax_rootmgs://sax-admin2/sax-root is /sax/test/1lama27b

+----------+-------------------------------------------------------+-----------------------------------------------------------------------+---------------+---------------------------+
| MODEL    | MODEL PATH                                            | CHECKPOINT PATH                                                       | # OF REPLICAS | (SELECTED) REPLICAADDRESS |
+----------+-------------------------------------------------------+-----------------------------------------------------------------------+---------------+---------------------------+
| llama27b | saxml.server.pax.lm.params.lm_cloud.LLaMA7BFP16TPUv5e | gs://${MODEL_BUCKET}/sax_models/llama2/7b/pax_7B/checkpoint_00000000/ | 1             | 10.182.0.28:10001         |
+----------+-------------------------------------------------------+-----------------------------------------------------------------------+---------------+---------------------------+

Les journaux Docker pour le serveur de modèles se présentent comme suit:

I1114 17:31:03.586631 140003787142720 model_service_base.py:532] Successfully loaded model for key: /sax/test/llama27b

INFO: Running command line: bazel-bin/saxml/bin/saxutil_/saxutil '--sax_rootmgs://sax-admin2/sax-root is /sax/test/1lama27b

Résoudre les problèmes

Si le déploiement échoue, consultez les journaux du serveur de modèles:

sudo docker logs -f sax-model-server

Pour un déploiement réussi, vous devez obtenir le résultat suivant:

Successfully loaded model for key: /sax/test/llama27b

Si les journaux n'indiquent pas que le modèle a été déployé, vérifiez sa configuration et le chemin d'accès à son point de contrôle.

Générer des réponses

Vous pouvez utiliser l'outil saxutil pour générer des réponses aux requêtes.

Générer des réponses à une question:

saxutil lm.generate -extra="temperature:0.2"  /sax/test/MODEL "Q: Who is Harry Potter's mother? A:"

La sortie devrait ressembler à ce qui suit :

INFO: Running command line: bazel-bin/saxml/bin/saxutil_/saxutil '--sax_rootmgs://sax-admin2/sax-root' lm.generate /sax/test/llama27b 'Q: Who is Harry Potter's mother? A: `
+-------------------------------+------------+
| GENERATE                      | SCORE      |
+-------------------------------+------------+
| 1. Harry Potter's mother is   | -20.214787 |
| Lily Evans. 2. Harry Potter's |            |
| mother is Petunia Evans       |            |
| (Dursley).                    |            |
+-------------------------------+------------+

Interagir avec le modèle depuis un client

Le référentiel SAX comprend des clients que vous pouvez utiliser pour interagir avec une cellule SAX. Les clients sont disponibles en C++, Python et Go. L'exemple suivant montre comment créer un client Python.

  1. Créez le client Python:

    bazel build saxml/client/python:sax.cc --compile_one_dependency

  2. Ajoutez le client à PYTHONPATH. Cet exemple suppose que votre répertoire d'accueil contient saxml:

    export PYTHONPATH=${PYTHONPATH}:$HOME/saxml/bazel-bin/saxml/client/python/

  3. Interagissez avec SAX à partir du shell Python:

    $ python3
Python 3.10.12 (main, Jun 11 2023, 05:26:28) [GCC 11.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import sax
>>>

Interagir avec le modèle depuis un point de terminaison HTTP

Pour interagir avec le modèle à partir d'un point de terminaison HTTP, créez un client HTTP:

  1. Créer une VM Compute Engine :

    export PROJECT_ID=PROJECT_ID
export ZONE=ZONE
export HTTP_SERVER_NAME=HTTP_SERVER_NAME
export SERVICE_ACCOUNT=SERVICE_ACCOUNT
export MACHINE_TYPE=e2-standard-8
gcloud compute instances create $HTTP_SERVER_NAME --project=$PROJECT_ID --zone=$ZONE \
  --machine-type=$MACHINE_TYPE \
  --network-interface=network-tier=PREMIUM,stack-type=IPV4_ONLY,subnet=default \
  --maintenance-policy=MIGRATE --provisioning-model=STANDARD \
  --service-account=$SERVICE_ACCOUNT \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=http-server,https-server \
  --create-disk=auto-delete=yes,boot=yes,device-name=$HTTP_SERVER_NAME,image=projects/ml-images/global/images/c0-deeplearning-common-cpu-v20230925-debian-10,mode=rw,size=500,type=projects/$PROJECT_ID/zones/$ZONE/diskTypes/pd-balanced \
  --no-shielded-secure-boot \
  --shielded-vtpm \
  --shielded-integrity-monitoring \
  --labels=goog-ec-src=vm_add-gcloud \
  --reservation-affinity=any

  2. Connectez-vous en SSH à la VM Compute Engine:

    gcloud compute ssh $HTTP_SERVER_NAME --project=$PROJECT_ID --zone=$ZONE

  3. Clonez le dépôt GitHub AI on GKE:

    git clone https://github.com/GoogleCloudPlatform/ai-on-gke.git

  4. Accédez au répertoire du serveur HTTP:

    cd ai-on-gke/tools/saxml-on-gke/httpserver

  5. Créez le fichier Docker:

    docker build -f Dockerfile -t sax-http .

  6. Exécutez le serveur HTTP:

    docker run -e SAX_ROOT=gs://${GSBUCKET}/sax-root -p 8888:8888 -it sax-http

Testez votre point de terminaison à partir de votre ordinateur local ou d'un autre serveur ayant accès au port 8888 à l'aide des commandes suivantes:

  1. Exportez les variables d'environnement correspondant à l'adresse IP et au port de votre serveur:

    export LB_IP=HTTP_SERVER_EXTERNAL_IP
export PORT=8888

  2. Définissez la charge utile JSON contenant le modèle et la requête:

    json_payload=$(cat  << EOF
{
  "model": "/sax/test/MODEL",
  "query": "Example query"
}
EOF
)

  3. Envoyez la requête :

    curl --request POST --header "Content-type: application/json" -s $LB_IP:$PORT/generate --data "$json_payload"

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.

Lorsque vous avez terminé ce tutoriel, procédez comme suit pour nettoyer vos ressources.

  1. Supprimez votre Cloud TPU.

    $ gcloud compute tpus tpu-vm delete $TPU_NAME  --zone $ZONE

  2. Supprimez votre instance Compute Engine, le cas échéant.

    gcloud compute instances delete INSTANCE_NAME

  3. Supprimez votre bucket Cloud Storage et son contenu.

    gcloud storage rm --recursive gs://BUCKET_NAME

Étapes suivantes