Inférence Cloud TPU v5e [version Preview publique]
Premiers pas
Présentation et avantages
Cloud TPU v5e est l'accélérateur d'IA de dernière génération de Google Cloud. Avec un encombrement réduit de 256 puces par pod, les pods v5e sont optimisés pour l'entraînement, l'ajustement et l'inférence basés sur les transformateurs et sur le texte vers l'image et sur les réseaux de neurones convolutifs.
Concepts
Si vous ne connaissez pas les Cloud TPU, consultez la page d'accueil de la documentation sur les TPU.
Microprocesseurs
Il y a 256 chips dans une seule version v5e avec 8 chips par hôte. Pour en savoir plus, consultez Architecture du système.
Cœurs
Les puces TPU possèdent un ou deux TensorCore pour effectuer la multiplication matricielle. Comme pour les pods v2 et v3, la version v5e comporte un seul TensorCore par puce. En revanche, les pods v4 possèdent 2 TensorCore par puce. Pour en savoir plus sur TensorCores v5e, consultez la section Architecture système. Vous trouverez des informations supplémentaires sur TensorCores dans cet article ACM.
L'hôte
Un hôte est un ordinateur physique (processeur) qui exécute des VM. Un hôte peut exécuter plusieurs VM à la fois.
Inférence par lot
L'inférence par lot ou hors connexion fait généralement référence à des opérations d'inférence en dehors des pipelines de production, généralement sur un grand nombre d'entrées. L'inférence par lot est utilisée pour des tâches hors connexion telles que l'étiquetage des données, ainsi que pour l'évaluation du modèle entraîné. Les SLO de latence ne constituent pas une priorité pour l'inférence par lot.
Diffusion
La diffusion fait référence au processus de déploiement d'un modèle de machine learning entraîné dans un environnement de production, où il peut être utilisé pour effectuer des prédictions ou prendre des décisions. Les SLO de latence constituent une priorité de diffusion.
Hôte unique et multi-hôte
Les segments utilisant moins de huit chips utilisent au maximum un hôte. Les segments comportant plus de huit puces, ont accès à plusieurs hôtes et peuvent exécuter un entraînement distribué à l'aide de plusieurs hôtes. L'aperçu n'est pas compatible avec la diffusion sur plusieurs hôtes. Le nombre maximal de chips autorisés dans une tâche de diffusion est de huit.
Ressource en file d'attente
Représentation des ressources TPU, utilisée pour mettre en file d'attente et gérer une requête pour un environnement TPU à une ou plusieurs tranches. Consultez le guide de l'utilisateur pour les ressources en file d'attente pour plus d'informations.
VM Cloud TPU
Machine virtuelle exécutant Linux et ayant accès aux TPU sous-jacents Pour les TPU v5e, chaque VM TPU a un accès direct à 1, 4 ou 8 puces, selon le type d'accélérateur spécifié par l'utilisateur. Une VM TPU est également appelée nœud de calcul.
Architecture du système
Chaque puce v5e contient un seul TensorCore. Chaque TensorCore comporte quatre unités de multiplication matricielle (MXU), une unité vectorielle et une unité scalaire. Le tableau suivant présente les spécifications de clé et leurs valeurs pour une version 5e. Les spécifications des pods sont incluses dans le tableau qui suit les spécifications des puces.
| Caractéristiques des puces de clés | Valeurs v5e |
| Pic de calcul par puce (bf16) | 197 TFLOPs |
| Pic de calcul par puce (Int8) | 393 TFLOPs |
| Capacité et bande passante HBM2 | 16 Go, 819 Go/s |
| Interchip Interconnect BW | 1 600 Gbit/s |
| Réduction totale de la bande passante par pod | 51,2 To/s |
| Bande passante bissectionnelle par pod | 1,6 To/s |
| Bande passante réseau des centres de données par pod | 6,4 Tbit/s |
| Spécifications clés des pods | Valeurs v5e |
| Taille du pod TPU | 256 chips |
| Topologie d'interconnexion | 2D Torus |
| Pic de calcul par pod | 100 PetaOps(Int8) |
| Réduction totale de la bande passante par pod | 51,2 To/s |
| Bande passante bissectionnelle par pod | 1,6 To/s |
| Bande passante réseau des centres de données par pod | 6,4 Tbit/s |
Puce TPU v5e
Le schéma suivant illustre une puce TPU v5e.
Types d'accélérateurs
Cloud TPU v5e est un produit combiné d'entraînement et d'inférence.
L'option AcceleratorType permet de différencier l'environnement TPU provisionné pour l'entraînement de l'environnement provisionné pour la diffusion. Les tâches d'entraînement sont optimisées pour le débit et la disponibilité, tandis que les tâches de diffusion sont optimisées pour la latence. Par conséquent, une tâche d'entraînement exécutée sur des TPU provisionnés pour la diffusion peut avoir une disponibilité inférieure et, de la même manière, une tâche de diffusion exécutée sur des TPU provisionnés pour l'entraînement peut présenter une latence plus élevée.
AcceleratorType utilise le nombre de cœurs de Tensor dans le nœud pour décrire la taille de la tranche. AcceleratorType est une chaîne formatée "v$VERSION_NUMBER-$CORES_COUNT".
Les formes de tranche 2D suivantes sont compatibles avec la version 5e:
| Topology | Nombre de puces TPU | Nombre d'hôtes |
| 1x1 | 1 | 1/8 |
| 2x2 | 4 | 1/2 |
| 2x4 | 8 | 1 |
| 4x4 | 16 | 2 |
| 4x8 | 32 | 4 |
| 8x8 | 64 | 8 |
| 8x16 | 128 | 16 |
| 16x16 | 256 | 32 |
Types Cloud TPU v5e pour la diffusion
Certains types de TPU v5e offrent une meilleure disponibilité pour l'inférence. Ces types n'acceptent qu'un maximum de huit puces v5e (un seul hôte). Les configurations suivantes sont acceptées: tranches 1 x 1, 2 x 2 et 2 x 4. Chaque tranche comporte respectivement 1, 4 et 8 chips.
La diffusion sur plus de huit puces v5e, c'est-à-dire la diffusion multi-hôtes, fait partie de la feuille de route Cloud TPU et sera disponible ultérieurement.
Pour provisionner des TPU pour une tâche de diffusion, utilisez les types d'accélérateurs suivants dans votre CLI ou votre requête de création de TPU d'API. Toutes les capacités de diffusion de la version v5e se trouvent actuellement dans la zone us-west4-a:
- V5E-1
- V5E-4
V5E-8
Types de VM
Chaque VM d'une tranche de TPU peut contenir une, quatre ou huit puces. Les tranches à quatre puces ou plus petites auront le même nœud NUMA (pour en savoir plus sur les nœuds NUMA, consultez la section Architecture du système). Pour les VM TPU à 8 puces, la communication CPU-TPU est plus efficace au sein des partitions NUMA. Par exemple, dans la figure ci-dessous, la communication CPU0-Chip0 sera plus rapide que la communication CPU0-Chip4.
Comparaison des types de VM:
Dans la version Preview publique, les clients utilisant l'inférence ont accès à une puce (v5e-1), à quatre puces (v5e-4) et à huit puces (v5e-8).
| Type de VM | n2d-48-24-v5lite-tpu | n2d-192-112-v5lite-tpu | n2d-384-224-v5lite-tpu |
| Nombre de puces v5e | 1 | 4 | 8 |
| Nombre de vCPU | 24 | 112 | 224 |
| RAM (Go) | 48 | 192 | 384 |
| Nombre de nœuds sur NUMA | 1 | 1 | 2 |
| Applicable à | V5E-1 | V5E-4 | V5E-8 |
| Perturbation | Élevée | Moyenne | Faible |
Pour libérer de l'espace pour les VM comportant plus de puces, les programmeurs peuvent préempter les VM comportant moins de puces. Les VM à huit puces sont donc susceptibles de préempter les VM 1 et 4 puces.
Premiers pas
Sécuriser la capacité
Cloud TPU v5e est désormais en version Preview publique. Pour commencer à utiliser Cloud TPU v5e pour vos charges de travail d'IA, veuillez contacter le service commercial Cloud.
Préparer un projet Google Cloud
Connectez-vous à votre compte Google. Si ce n'est pas déjà fait, créez un compte.
Dans Cloud Console, sélectionnez ou créez un projet Cloud sur la page du sélecteur de projet.
La configuration de la facturation est requise pour toute utilisation de Google Cloud. Assurez-vous donc que la facturation est activée pour votre projet.
La facturation de l'utilisation de la version Preview publique respecte les tarifs régionaux standards de la page Tarifs de Cloud TPU.
Installez les composants gcloud alpha.
Activez l'API TPU à l'aide de la commande
gcloudsuivante dans Cloud Shell. (Vous pouvez également l'activer à partir de la console Google Cloud.)gcloud services enable tpu.googleapis.com
Activez le compte de service TPU.
Les comptes de service permettent au service Cloud TPU d'accéder à d'autres services Google Cloud. Un compte de service géré par l'utilisateur est une pratique Google Cloud recommandée. Suivez ces guides pour créer et attribuer les rôles suivants à votre compte de service. Les rôles suivants sont nécessaires:
- Administrateur TPU
- Administrateur de l'espace de stockage
- Rédacteur de journaux
- Rédacteur de métriques Monitoring
Configurez le projet et la zone.
Votre ID de projet est le nom de votre projet affiché dans la console Cloud. Zone par défaut pour Cloud TPU v5e ia
us-west4-a.export PROJECT_ID=project-ID export ZONE=us-west4-a gcloud alpha compute tpus tpu-vm service-identity create --zone=${ZONE} gcloud auth login gcloud config set project ${PROJECT} gcloud config set compute/zone ${ZONE}Demandez l'accès aux artefacts de la version preview de l'inférence Cloud TPU.
Envoyez à l'équipe TPU le compte de service que vous prévoyez d'utiliser pour la VM TPU. Le compte par défaut est le compte de service Compute Engine par défaut (${PROJECT_ID}-compute@developer.gserviceaccount.com) qui se trouve sur votre page IAM.
Provisionnez l'environnement Cloud TPU v5e.
Une version v5e est gérée en tant que ressource en file d'attente. La capacité peut être provisionnée à l'aide de la commande
queued-resource create.Créez des variables d'environnement pour l'ID de projet, le type d'accélérateur, la zone, la version d'exécution et le nom du TPU.
export PROJECT_ID=project_ID export ACCELERATOR_TYPE=v5e-1 export ZONE=us-west4-a export RUNTIME_VERSION=v2-alpha-tpuv5-lite export SERVICE_ACCOUNT=service_account export TPU_NAME=tpu-name export QUEUED_RESOURCE_ID=queued_resource_id
Descriptions des variables
- Nom du projet. Utilisez le nom de votre projet Google.
- Consultez la section Types d'accélérateurs pour connaître les types d'accélérateurs compatibles.
- Toute la capacité de la version Preview publique sera située dans la région us-west4-a.
- v2-alpha-tpuv5-lite
- Il s'agit de l'adresse e-mail de votre compte de service que vous pouvez trouver dans la Google Cloud Console -> IAM -> Comptes de service. Par exemple: tpu-service-account@myprojectID.iam.gserviceaccount.com.
- L'ID de requête attribué par l'utilisateur est attribué au TPU créé au moment de la ressource en file d'attente.
- ID attribué par l'utilisateur pour la requête de ressources en file d'attente.
PROJECT_IDACCELERATOR_TYPEZONERUNTIME_VERSIONSERVICE_ACCOUNTTPU_NAMEQUEUED_RESOURCE_IDCréez une ressource TPU.
gcloud alpha 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} \ --reservedSi vous souhaitez supprimer la ressource que vous avez réservée, vous devez d'abord supprimer la ressource TPU_NAME, puis supprimer également la requête de ressource en file d'attente.
gcloud alpha compute tpus delete $TPU_NAME --zone ${ZONE} --project ${PROJECT_ID} gcloud alpha compute tpus queued-resources delete ${QUEUED_RESOURCE_ID} \ --project ${PROJECT_ID} \ --zone ${ZONE}Se connecter en SSH aux VM TPU
Pour exécuter du code sur vos VM TPU, vous devez
SSHsur chaque VM TPU. Dans cet exemple, avec la version v5e-1, il n'existe qu'une seule VM TPU.gcloud compute config-ssh gcloud compute tpus tpu-vm ssh $TPU_NAME --zone $ZONE --project $PROJECT_ID
Gérer vos VM TPU
Pour connaître toutes les options de gestion des TPU pour vos VM TPU, consultez la page Gérer les TPU.
Développer et exécuter
Cette section décrit le processus de configuration général pour l'inférence de modèles personnalisés à l'aide de JAX ou PyTorch sur Cloud TPU v5e. La compatibilité avec TensorFlow sera bientôt activée.
Pour obtenir des instructions d'entraînement pour la version 5e, consultez le guide d'entraînement de la version 5e.
Exécuter une inférence sur la version 5e
Pile logicielle d'inférence
Les sections suivantes présentent les détails de la pile logicielle d'inférence. Ce document porte sur l'inférence à hôte unique pour les modèles entraînés avec JAX, TensorFlow (TF) et PyTorch.
Dans cette section, nous partons du principe que vous avez déjà configuré votre projet Google Cloud conformément aux instructions de la section Préparer un projet Google Cloud.
Inférence et inférence de modèle JAX
La section suivante décrit le workflow associé à l'inférence de modèle JAX.
L'inférence JAX se fait de deux façons, comme illustré dans le schéma.
Cette section traite du chemin de production pour les modèles JAX via jax2tf et TensorFlow Serving.
- Utiliser
jax2tfpour convertir le modèle au format TensorFlow 2 et l'enregistrer - Utiliser le convertisseur d'inférence pour convertir le modèle enregistré
- Utiliser TensorFlow Serving pour diffuser le modèle
Utiliser jax2tf pour convertir le modèle et l'enregistrer
Veuillez consulter la page sur l'interopérabilité JAX et TensorFlow pour convertir et enregistrer votre modèle JAX dans TensorFlow.
# Inference function def model_jax(params, inputs): return params[0] + params[1] * inputs # Wrap the parameter constants as tf.Variables; this will signal to the model # saving code to save those constants as variables, separate from the # computation graph. params_vars = tf.nest.map_structure(tf.Variable, params) # Build the prediction function by closing over the `params_vars`. If you # instead were to close over `params` your SavedModel would have no variables # and the parameters will be included in the function graph. prediction_tf = lambda inputs: jax2tf.convert(model_jax)(params_vars, inputs) my_model = tf.Module() # Tell the model saver what the variables are. my_model._variables = tf.nest.flatten(params_vars) my_model.f = tf.function(prediction_tf, jit_compile=True, autograph=False) tf.saved_model.save(my_model)
Utiliser le convertisseur d'inférence pour convertir le modèle enregistré
La procédure à suivre pour le convertisseur d'inférence est décrite dans le guide du convertisseur d'inférence.
Utiliser TensorFlow Serving
Les étapes pour TensorFlow Serving sont décrites dans la section TensorFlow Serving.
Exemple de diffusion d'un modèle JAX de bout en bout
Conditions préalables :
Vous devez configurer vos identifiants Docker, et extraire le convertisseur d'inférences et l'image Docker TensorFlow Serving. Si vous ne l'avez pas déjà fait, exécutez les commandes suivantes:
sudo usermod -a -G docker ${USER}
newgrp docker
gcloud auth configure-docker \
us-docker.pkg.dev
docker pull us-docker.pkg.dev/cloud-tpu-images/inference/tpu-inference-converter-cli:2.13.0
docker pull us-docker.pkg.dev/cloud-tpu-images/inference/tf-serving-tpu:2.13.0
Téléchargez le code de démonstration : SSH sur votre VM TPU et installez le code de démonstration d'inférence.
gsutil -m cp -r \ "gs://cloud-tpu-inference-public/demo" \ .
Installez les dépendances de démonstration JAX. Sur votre VM TPU, installez requirements.txt.
pip install -r ./demo/jax/requirements.txt
Exécuter la démo de diffusion E2E de JAX BERT
Le modèle BERT pré-entraîné est tiré du modèle Hugging Face.
Exportez un modèle enregistré TF2 compatible avec le TPU à partir d'un modèle BERT Flax:
cd demo/jax/bert
python3 export_bert_model.py
Lancez le conteneur de serveur de modèles TensorFlow correspondant au modèle:
docker run -t --rm --privileged -d \ -p 8500:8500 -p 8501:8501 \ --mount type=bind,source=/tmp/jax/bert_tpu,target=/models/bert \ -e MODEL_NAME=bert \ us-docker.pkg.dev/cloud-tpu-images/inference/tf-serving-tpu:2.13.0
Vérifiez le journal du conteneur du serveur de modèle, et assurez-vous que le serveur gRPC et le serveur HTTP sont opérationnels:
CONTAINER_ID=$(docker ps | grep "tf-serving-tpu" | awk '{print $1}') docker logs ${CONTAINER_ID}Si le journal se termine par les informations suivantes, cela signifie que le serveur est prêt à traiter les requêtes. Cela prend environ 30 secondes.
2023-04-08 00:43:10.481682: I tensorflow_serving/model_servers/server.cc:409] Running gRPC ModelServer at 0.0.0.0:8500 ... [warn] getaddrinfo: address family for nodename not supported 2023-04-08 00:43:10.520578: I tensorflow_serving/model_servers/server.cc:430] Exporting HTTP/REST API at:localhost:8501 ... [evhttp_server.cc : 245] NET_LOG: Entering the event loop ...
Envoyez la requête au serveur de modèles.
python3 bert_request.py
Le résultat doit ressembler à ce qui suit :
For input "The capital of France is [MASK].", the result is ". the capital of france is paris.." For input "Hello my name [MASK] Jhon, how can I [MASK] you?", the result is ". hello my name is jhon, how can i help you?."
effectuer un nettoyage.
Veillez à nettoyer le conteneur Docker avant d'exécuter d'autres démonstrations.
CONTAINER_ID=$(docker ps | grep "tf-serving-tpu" | awk '{print $1}') docker stop ${CONTAINER_ID}Nettoyez les artefacts du modèle:
sudo rm -rf /tmp/jax/
Lancer la démonstration de diffusion stable de diffusion de bout en bout de JAX
Le modèle Stable Diffusion pré-entraîné est issu d'un Hugging Face.
Exportez le modèle enregistré TF2 compatible avec le TPU à partir du modèle Flax Stable Diffusion:
cd demo/jax/stable_diffusion
python3 export_stable_diffusion_model.py
Lancez le conteneur de serveur de modèles TensorFlow correspondant au modèle:
docker run -t --rm --privileged -d \ -p 8500:8500 -p 8501:8501 \ --mount type=bind,source=/tmp/jax/stable_diffusion_tpu,target=/models/stable_diffusion \ -e MODEL_NAME=stable_diffusion \ us-docker.pkg.dev/cloud-tpu-images/inference/tf-serving-tpu:2.13.0
Vérifiez le journal du conteneur du serveur de modèle, et assurez-vous que le serveur gRPC et le serveur HTTP sont opérationnels:
CONTAINER_ID=$(docker ps | grep "tf-serving-tpu" | awk '{print $1}') docker logs ${CONTAINER_ID}Si le journal se termine par les informations suivantes, cela signifie que le serveur est prêt à traiter les requêtes. Cela prend environ deux minutes.
2023-04-08 00:43:10.481682: I tensorflow_serving/model_servers/server.cc:409] Running gRPC ModelServer at 0.0.0.0:8500 ... [warn] getaddrinfo: address family for nodename not supported 2023-04-08 00:43:10.520578: I tensorflow_serving/model_servers/server.cc:430] Exporting HTTP/REST API at:localhost:8501 ... [evhttp_server.cc : 245] NET_LOG: Entering the event loop ...
Envoyez la requête au serveur de modèles.
python3 stable_diffusion_request.py
L'invite est "Painting of a squirrel sk in New York" et l'image de sortie sera enregistrée sous le nom
stable_diffusion_images.jpgdans votre répertoire actuel.effectuer un nettoyage.
Veillez à nettoyer le conteneur Docker avant d'exécuter d'autres démonstrations.
CONTAINER_ID=$(docker ps | grep "tf-serving-tpu" | awk '{print $1}') docker stop ${CONTAINER_ID}Nettoyer les artefacts du modèle
sudo rm -rf /tmp/jax/
Inférence de modèles et inférence TensorFlow
Les sections suivantes décrivent le workflow associé à l'inférence de modèle TensorFlow.
- Utiliser le convertisseur d'inférence pour convertir le modèle
- Utiliser TensorFlow Serving pour diffuser le modèle
Convertisseur d'inférence
Le convertisseur d'inférences Cloud TPU prépare et optimise un modèle exporté depuis TensorFlow ou JAX pour l'inférence TPU. Le convertisseur s'exécute dans une interface système locale ou dans l'interface système de la VM TPU. L'interface système de VM TPU est recommandée, car les outils de ligne de commande nécessaires au convertisseur y sont préinstallés. Pour en savoir plus sur le convertisseur d'inférence, consultez le guide de l'utilisateur du convertisseur d'inférence.
Prérequis
Le modèle doit être exporté depuis TensorFlow ou JAX au format SavedModel.
Le modèle doit disposer d'un alias de fonction pour la fonction TPU. Consultez les exemples de code du Guide de l'utilisateur du convertisseur d'inférence pour savoir comment procéder. Les exemples suivants utilisent
tpu_funccomme alias de la fonction TPU.Assurez-vous que le processeur de votre machine est compatible avec les instructions AVX (Advanced Vector eXtensions), car la bibliothèque Tensorflow (la dépendance du convertisseur d'inférences Cloud TPU) est compilée pour utiliser les instructions AVX. La plupart des processeurs sont compatibles avec AVX.
- Vous pouvez exécuter
lscpu | grep avxpour vérifier si l'ensemble d'instructions AVX est compatible.
- Vous pouvez exécuter
Premiers pas
Configurez l'environnement de VM TPU Configurez l'environnement en procédant comme suit, en fonction de l'interface système que vous utilisez:
Shell de VM TPU
- Dans l'interface système de la VM TPU, exécutez les commandes suivantes pour autoriser l'utilisation de Docker non racine:
sudo usermod -a -G docker ${USER} newgrp docker- Initialisez vos assistants d'identification Docker:
gcloud auth configure-docker \ us-docker.pkg.dev
Interface système locale
Dans votre interface système locale, configurez l'environnement en procédant comme suit:
Installez le SDK Cloud, qui inclut l'outil de ligne de commande
gcloud.Installez Docker:
Autoriser l'utilisation de Docker non racine:
sudo usermod -a -G docker ${USER} newgrp dockerConnectez-vous à votre environnement:
gcloud auth login
Initialisez vos assistants d'identification Docker:
gcloud auth configure-docker \ us-docker.pkg.dev
Extrayez l'image Docker du convertisseur d'inférence:
CONVERTER_IMAGE=us-docker.pkg.dev/cloud-tpu-images/inference/tpu-inference-converter-cli:2.13.0 docker pull ${CONVERTER_IMAGE}
Image du convertisseur
L'image est destinée aux conversions uniques de modèles. Définissez les chemins d'accès du modèle et ajustez les options de conversion en fonction de vos besoins. La section Exemples d'utilisation du Guide de l'utilisateur du convertisseur d'inférence fournit plusieurs cas d'utilisation courants.
docker run \
--mount type=bind,source=${MODEL_PATH},target=/tmp/input,readonly \
--mount type=bind,source=${CONVERTED_MODEL_PATH},target=/tmp/output \
${CONVERTER_IMAGE} \
--input_model_dir=/tmp/input \
--output_model_dir=/tmp/output \
--converter_options_string='
tpu_functions {
function_alias: "tpu_func"
}
batch_options {
num_batch_threads: 2
max_batch_size: 8
batch_timeout_micros: 5000
allowed_batch_sizes: 2
allowed_batch_sizes: 4
allowed_batch_sizes: 8
max_enqueued_batches: 10
}
'
La section suivante explique comment exécuter ce modèle avec un serveur de modèles TensorFlow.
TensorFlow Serving
Les instructions suivantes montrent comment diffuser votre modèle TensorFlow sur des VM TPU.
Prérequis :
Si ce n'est pas déjà fait, configurez vos identifiants Docker:
Téléchargez l'image Docker TensorFlow Serving pour votre VM TPU.
Définir des exemples de variables d'environnement
export YOUR_LOCAL_MODEL_PATH=model-path export MODEL_NAME=model-name # Note: this image name may change later. export IMAGE_NAME=us-docker.pkg.dev/cloud-tpu-images/inference/tf-serving-tpu:2.13.0
Télécharger l'image Docker
docker pull ${IMAGE_NAME}Diffusez votre modèle TensorFlow à l'aide de l'image Docker TensorFlow Serving sur votre VM TPU.
# PORT 8500 is for gRPC model server and 8501 is for HTTP/REST model server. docker run -t --rm --privileged -d \ -p 8500:8500 -p 8501:8501 \ --mount type=bind,source=${YOUR_LOCAL_MODEL_PATH},target=/models/${MODEL_NAME} \ -e MODEL_NAME=${MODEL_NAME} \ ${IMAGE_NAME}Suivez l'API du client de diffusion pour interroger votre modèle.
Exemple d'inférence de modèle TensorFlow de bout en bout:
Condition préalable: assurez-vous d'avoir déjà configuré les identifiants Docker et extrait le convertisseur d'inférences et l'image Docker TensorFlow Serving. Si ce n'est pas le cas, exécutez les commandes suivantes:
sudo usermod -a -G docker ${USER}
newgrp docker
gcloud auth configure-docker \
us-docker.pkg.dev
docker pull us-docker.pkg.dev/cloud-tpu-images/inference/tpu-inference-converter-cli:2.13.0
docker pull us-docker.pkg.dev/cloud-tpu-images/inference/tf-serving-tpu:2.13.0
Téléchargez le code de démonstration:
gsutil -m cp -r \ "gs://cloud-tpu-inference-public/demo" \ .
Installez les dépendances de démonstration TensorFlow:
pip install -r ./demo/tf/requirements.txt
Exécuter la démonstration de diffusion E2E de TensorFlow ResNet-50
Exportez un modèle enregistré TF2 compatible avec le TPU à partir du modèle Keras ResNet-50.
cd demo/tf/resnet-50
python3 export_resnet_model.py
Lancer le conteneur de serveur de modèles TensorFlow pour le modèle
docker run -t --rm --privileged -d \ -p 8500:8500 -p 8501:8501 \ --mount type=bind,source=/tmp/tf/resnet_tpu,target=/models/resnet \ -e MODEL_NAME=resnet \ us-docker.pkg.dev/cloud-tpu-images/inference/tf-serving-tpu:2.13.0
Vérifiez le journal du conteneur du serveur de modèle, et assurez-vous que le serveur gRPC et le serveur HTTP sont opérationnels:
CONTAINER_ID=$(docker ps | grep "tf-serving-tpu" | awk '{print $1}') docker logs ${CONTAINER_ID}Si le journal se termine par les informations suivantes, cela signifie que le serveur est prêt à traiter les requêtes. Cela prend environ 30 secondes.
2023-04-08 00:43:10.481682: I tensorflow_serving/model_servers/server.cc:409] Running gRPC ModelServer at 0.0.0.0:8500 ... [warn] getaddrinfo: address family for nodename not supported 2023-04-08 00:43:10.520578: I tensorflow_serving/model_servers/server.cc:430] Exporting HTTP/REST API at:localhost:8501 ... [evhttp_server.cc : 245] NET_LOG: Entering the event loop ...
Envoyez la requête au serveur de modèles.
L'image de la demande est une banane disponible à l'adresse https://i.imgur.com/j9xCCzn.jpeg .
python3 resnet_request.py
Le résultat doit ressembler à ce qui suit :
Predict result: [[('n07753592', 'banana', 0.94921875), ('n03532672', 'hook', 0.022338867), ('n07749582', 'lemon', 0.005126953)]]effectuer un nettoyage.
Veillez à nettoyer le conteneur Docker avant d'exécuter d'autres démonstrations.
CONTAINER_ID=$(docker ps | grep "tf-serving-tpu" | awk '{print $1}') docker stop ${CONTAINER_ID}Nettoyez les artefacts du modèle:
sudo rm -rf /tmp/tf/
Inférence et inférence de modèles PyTorch
Les sections suivantes décrivent le workflow associé à l'inférence de modèle PyTorch:
- Écrire un gestionnaire de modèle Python pour le chargement et l'inférence à l'aide de TorchDynamo et PyTorch/XLA
- Utiliser TorchModelArchiver pour créer une archive de modèle
- Utiliser TorchServe pour diffuser le modèle
TorchDynamo et PyTorch/XLA
TorchDynamo (Dynamo) est un compilateur JIT de niveau Python conçu pour accélérer les programmes PyTorch non modifiés. Il fournit une API propre à laquelle se connecter les backends de compilation. Sa principale fonctionnalité consiste à modifier de manière dynamique le bytecode Python juste avant l'exécution. Dans la version PyTorch/XLA 2.0, un backend expérimental pour Dynamo est fourni pour l'inférence et l'entraînement.
Dynamo fournit un graphe Torch FX (FX) lorsqu'il reconnaît un schéma de modèle et que PyTorch/XLA utilise une approche Lazy Tensor pour compiler le graphe de change et renvoyer la fonction compilée. Pour en savoir plus sur les détails techniques de l'implémentation du dynamo de PyTorch/XLA, consultez le post de discussion sur les développeurs de PyTorch et la documentation de TorchDynamo. Pour en savoir plus, consultez cet article de blog.
Voici un petit exemple de code d'exécution d'inférence densenet161 avec torch.compile.
import torch
import torchvision
import torch_xla.core.xla_model as xm
def eval_model(loader):
device = xm.xla_device()
xla_densenet161 = torchvision.models.densenet161().to(device)
xla_densenet161.eval()
dynamo_densenet161 = torch.compile(
xla_densenet161, backend='torchxla_trace_once')
for data, _ in loader:
output = dynamo_densenet161(data)
TorchServe
L'image Docker Cloud TPU TorchServe vous permet de diffuser le modèle en mode rapide PyTorch à l'aide de TorchServe sur une VM Cloud TPU.
Vous pouvez utiliser l'image Docker torchserve-tpu fournie, prête à diffuser votre modèle PyTorch archivé sur une VM Cloud TPU.
Configurez l'authentification pour Docker:
sudo usermod -a -G docker ${USER}
newgrp docker
gcloud auth configure-docker \
us-docker.pkg.dev
Extrayez l'image Docker Cloud TPU TorchServe vers votre VM TPU:
CLOUD_TPU_TORCHSERVE_IMAGE_URL=us-docker.pkg.dev/cloud-tpu-images/inference/torchserve-tpu:v0.8.2-20230829
docker pull ${CLOUD_TPU_TORCHSERVE_IMAGE_URL}
Collecter les artefacts de modèle
Pour commencer, vous devez fournir un gestionnaire de modèles qui indique au nœud de calcul du serveur de modèles TorchServe de charger votre modèle, de traiter les données d'entrée et d'exécuter l'inférence. Vous pouvez utiliser les gestionnaires d'inférence par défaut TorchServe (source) ou développer votre propre gestionnaire de modèles personnalisés en suivant le fichier base_handler.py. Vous devrez peut-être également fournir le modèle entraîné et le fichier de définition du modèle.
Dans l'exemple Densenet 161 suivant, nous utilisons des artefacts de modèle et le gestionnaire de classificateur d'images par défaut fourni par TorchServe:
Le répertoire de travail est illustré ci-dessous.
CWD="$(pwd)"
WORKDIR="${CWD}/densenet_161"
mkdir -p ${WORKDIR}/model-store
mkdir -p ${WORKDIR}/logs
Téléchargez et copiez les artefacts de modèle à partir de l'exemple de classificateur d'images TorchServe:
git clone https://github.com/pytorch/serve.git cp ${CWD}/serve/examples/image_classifier/densenet_161/model.py ${WORKDIR} cp ${CWD}/serve/examples/image_classifier/index_to_name.json ${WORKDIR}Téléchargez les pondérations du modèle:
wget https://download.pytorch.org/models/densenet161-8d451a50.pth -O densenet161-8d451a50.pth mv densenet161-8d451a50.pth ${WORKDIR}Créez un fichier de configuration du modèle TorchServe pour utiliser le backend Dynamo:
echo 'pt2: "torchxla_trace_once"' >> ${WORKDIR}/model_config.yamlVous devriez voir les fichiers et répertoires ci-dessous:
>> ls ${WORKDIR} model_config.yaml index_to_name.json logs model.py densenet161-8d451a50.pth model-store
Générer un fichier d'archive du modèle
Pour diffuser votre modèle PyTorch avec Cloud TPU TorchServe, vous devez empaqueter votre gestionnaire de modèle et tous vos artefacts de modèle dans un fichier d'archive de modèle (*.mar) à l'aide de Torch Model Archiver.
Générez un fichier d'archive de modèle avec torch-model-archiver:
MODEL_NAME=Densenet161
docker run \
--privileged \
--shm-size 16G \
--name torch-model-archiver \
-it \
-d \
--rm \
--mount type=bind,source=${WORKDIR},target=/home/model-server/ \
${CLOUD_TPU_TORCHSERVE_IMAGE_URL} \
torch-model-archiver \
--model-name ${MODEL_NAME} \
--version 1.0 \
--model-file model.py \
--serialized-file densenet161-8d451a50.pth \
--handler image_classifier \
--export-path model-store \
--extra-files index_to_name.json \
--config-file model_config.yaml
Le fichier d'archive de modèle généré doit apparaître dans le répertoire model-store:
>> ls ${WORKDIR}/model-store
Densenet161.mar
Traiter des requêtes d'inférence
Maintenant que vous disposez du fichier d'archive du modèle, vous pouvez démarrer le serveur de modèles TorchServe et diffuser des requêtes d'inférence.
Démarrez le serveur de modèles TorchServe:
docker run \ --privileged \ --shm-size 16G \ --name torchserve-tpu \ -it \ -d \ --rm \ -p 7070:7070 \ -p 7071:7071 \ -p 8080:8080 \ -p 8081:8081 \ -p 8082:8082 \ -p 9001:9001 \ -p 9012:9012 \ --mount type=bind,source=${WORKDIR}/model-store,target=/home/model-server/model-store \ --mount type=bind,source=${WORKDIR}/logs,target=/home/model-server/logs \ ${CLOUD_TPU_TORCHSERVE_IMAGE_URL} \ torchserve \ --start \ --ncs \ --models ${MODEL_NAME}.mar \ --ts-config /home/model-server/config.propertiesÉtat du serveur de modèles de requête:
curl http://localhost:8080/ping
Si le serveur de modèles est opérationnel, le message suivant s'affiche:
{ "status": "Healthy" }Pour interroger les versions par défaut du modèle enregistré actuel, exécutez la commande suivante:
curl http://localhost:8081/models
Le modèle enregistré doit s'afficher:
{ "models": [ { "modelName": "Densenet161", "modelUrl": "Densenet161.mar" } ] }Pour télécharger une image à des fins d'inférence:
curl -O https://raw.githubusercontent.com/pytorch/serve/master/docs/images/kitten_small.jpg mv kitten_small.jpg ${WORKDIR}Pour envoyer une requête d'inférence au serveur de modèles, exécutez la commande suivante:
curl http://localhost:8080/predictions/${MODEL_NAME} -T ${WORKDIR}/kitten_small.jpgUn résultat semblable aux lignes suivantes doit s'afficher :
{ "tabby": 0.47878125309944153, "lynx": 0.20393909513950348, "tiger_cat": 0.16572578251361847, "tiger": 0.061157409101724625, "Egyptian_cat": 0.04997897148132324 }Journaux du serveur de modèles
Exécutez les commandes suivantes pour accéder aux journaux:
ls ${WORKDIR}/logs/ cat ${WORKDIR}/logs/model_log.logLe message suivant doit s'afficher dans votre journal:
"Modèle compilé avec le backend torchxla_trace_once"
Effectuer un nettoyage
Arrêtez le conteneur Docker:
rm -rf serve
rm -rf ${WORKDIR}
docker stop torch-model-archiver
docker stop torchserve-tpu
Diffusion d'un grand modèle de langage
SAX est un framework de diffusion permettant de diffuser des modèles volumineux pouvant nécessiter des TPU sur plusieurs hôtes pour s'exécuter avec GSPMD, tels que les grands modèles de langage basés sur PAX. PAX est un framework qui s'ajoute à JAX. Il permet d'entraîner des modèles à grande échelle afin d'effectuer des tests et des parallélisations avancés et entièrement configurables.
La section sur les clusters SAX décrit les éléments clés permettant de comprendre le fonctionnement de SAX. La section de diffusion du modèle SAX présente un exemple de diffusion de modèle à hôte unique avec un modèle GPTJ6B. SAX propose également la diffusion à hôtes multiples sur les Cloud TPU. Les utilisateurs peuvent exécuter des modèles sur des topologies de TPU plus grandes pour la version preview de la diffusion multi-hôte expérimentale. L'exemple ci-dessous avec un modèle de test de 175 milliards montre comment tester cette configuration.
Cluster SAX (cellule SAX)
Le serveur d'administration SAX et le serveur de modèles SAX sont deux composants essentiels qui exécutent un cluster SAX.
Serveur d'administration SAX
Le serveur d'administration SAX surveille et coordonne tous les serveurs de modèles SAX d'un cluster SAX. Dans un cluster SAX, vous pouvez lancer plusieurs serveurs d'administration SAX, où un seul serveur d'administration SAX est actif lors de l'élection du responsable, les autres étant des serveurs de secours. En cas de défaillance du serveur d'administration actif, un serveur d'administration de secours devient actif. Le serveur d'administration SAX actif attribue des instances répliquées de modèle et des requêtes d'inférence aux serveurs de modèles SAX disponibles.
Bucket de stockage administrateur SAX
Chaque cluster SAX nécessite un bucket Cloud Storage pour stocker la configuration et l'emplacement des serveurs d'administration SAX et des serveurs de modèles SAX dans le cluster SAX.
Serveur de modèles SAX
Le serveur de modèles SAX charge un point de contrôle du modèle et exécute une inférence avec GSPMD. Un serveur de modèles SAX s'exécute sur un seul nœud de calcul de VM TPU. La diffusion de modèles TPU à hôte unique nécessite un seul serveur de modèles SAX sur une VM TPU à hôte unique. L'inférence de modèles TPU à hôtes multiples nécessite un groupe de serveurs de modèles SAX sur une tranche de TPU multi-hôte.
Inférence du modèle SAX
La section suivante décrit le workflow de diffusion des modèles de langage à l'aide de SAX. Il utilise le modèle GPT-J 6B comme exemple pour la diffusion du modèle à hôte unique et un modèle de test 175 milliards pour la diffusion du modèle à hôte multiple.
Avant de commencer, installez les images Docker Cloud TPU SAX sur votre VM TPU:
sudo usermod -a -G docker ${USER}
newgrp docker
gcloud auth configure-docker us-docker.pkg.dev
SAX_ADMIN_SERVER_IMAGE_NAME="us-docker.pkg.dev/cloud-tpu-images/inference/sax-admin-server"
SAX_MODEL_SERVER_IMAGE_NAME="us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server"
SAX_UTIL_IMAGE_NAME="us-docker.pkg.dev/cloud-tpu-images/inference/sax-util"
SAX_VERSION=v1.0.0
export SAX_ADMIN_SERVER_IMAGE_URL=${SAX_ADMIN_SERVER_IMAGE_NAME}:${SAX_VERSION}
export SAX_MODEL_SERVER_IMAGE_URL=${SAX_MODEL_SERVER_IMAGE_NAME}:${SAX_VERSION}
export SAX_UTIL_IMAGE_URL="${SAX_UTIL_IMAGE_NAME}:${SAX_VERSION}"
docker pull ${SAX_ADMIN_SERVER_IMAGE_URL}
docker pull ${SAX_MODEL_SERVER_IMAGE_URL}
docker pull ${SAX_UTIL_IMAGE_URL}
Définissez d'autres variables que vous utiliserez plus tard:
export SAX_ADMIN_SERVER_DOCKER_NAME="sax-admin-server" export SAX_MODEL_SERVER_DOCKER_NAME="sax-model-server" export SAX_CELL="/sax/test"
Exemple de diffusion avec un modèle GPT-J 6B à hôte unique
La diffusion des modèles à hôte unique s'applique à la tranche de TPU à hôte unique, c'est-à-dire v5litepod-1, v5litepod-4 et v5litepod-8.
Créer un cluster SAX
Créez un bucket de stockage Cloud Storage pour le cluster SAX:
SAX_ADMIN_STORAGE_BUCKET=${your_admin_storage_bucket} gcloud storage buckets create gs://${SAX_ADMIN_STORAGE_BUCKET} \ --project=${PROJECT_ID}Vous aurez peut-être besoin d'un autre bucket de stockage Cloud Storage pour stocker le point de contrôle.
SAX_DATA_STORAGE_BUCKET=${your_data_storage_bucket}Connectez-vous à votre VM TPU à l'aide de SSH dans un terminal pour lancer le serveur d'administration SAX:
docker run \ --name ${SAX_ADMIN_SERVER_DOCKER_NAME} \ -it \ -d \ --rm \ --network host \ --env GSBUCKET=${SAX_ADMIN_STORAGE_BUCKET} \ ${SAX_ADMIN_SERVER_IMAGE_URL}Vous pouvez vérifier le journal Docker à l'aide de la commande suivante:
docker logs -f ${SAX_ADMIN_SERVER_DOCKER_NAME}Le résultat du journal ressemble à ce qui suit:
I0829 01:22:31.184198 7 config.go:111] Creating config fs_root: "gs://test_sax_admin/sax-fs-root" I0829 01:22:31.347883 7 config.go:115] Created config fs_root: "gs://test_sax_admin/sax-fs-root" I0829 01:22:31.360837 24 admin_server.go:44] Starting the server I0829 01:22:31.361420 24 ipaddr.go:39] Skipping non-global IP address 127.0.0.1/8. I0829 01:22:31.361455 24 ipaddr.go:39] Skipping non-global IP address ::1/128. I0829 01:22:31.361462 24 ipaddr.go:39] Skipping non-global IP address fe80::4001:aff:fe8e:fc8/64. I0829 01:22:31.361469 24 ipaddr.go:39] Skipping non-global IP address fe80::42:bfff:fef9:1bd3/64. I0829 01:22:31.361474 24 ipaddr.go:39] Skipping non-global IP address fe80::20fb:c3ff:fe5b:baac/64. I0829 01:22:31.361482 24 ipaddr.go:56] IPNet address 10.142.15.200 I0829 01:22:31.361488 24 ipaddr.go:56] IPNet address 172.17.0.1 I0829 01:22:31.456952 24 admin.go:305] Loaded config: fs_root: "gs://test_sax_admin/sax-fs-root" I0829 01:22:31.609323 24 addr.go:105] SetAddr /gcs/test_sax_admin/sax-root/sax/test/location.proto "10.142.15.200:10000" I0829 01:22:31.656021 24 admin.go:325] Updated config: fs_root: "gs://test_sax_admin/sax-fs-root" I0829 01:22:31.773245 24 mgr.go:781] Loaded manager state I0829 01:22:31.773260 24 mgr.go:784] Refreshing manager state every 10s I0829 01:22:31.773285 24 admin.go:350] Starting the server on port 10000 I0829 01:22:31.773292 24 cloud.go:506] Starting the HTTP server on port 8080
Lancez un serveur de modèle SAX à hôte unique dans le cluster SAX:
À ce stade, le cluster SAX ne contient que le serveur d'administration SAX. Vous pouvez vous connecter à votre VM TPU via SSH dans un deuxième terminal pour lancer un serveur de modèle SAX dans votre cluster SAX:
docker run \ --privileged \ -it \ -d \ --rm \ --network host \ --name ${SAX_MODEL_SERVER_DOCKER_NAME} \ --env SAX_ROOT=gs://${SAX_ADMIN_STORAGE_BUCKET}/sax-root \ ${SAX_MODEL_SERVER_IMAGE_URL} \ --sax_cell=${SAX_CELL} \ --port=10001 \ --platform_chip=tpuv4 \ --platform_topology=1x1Vous pouvez vérifier le journal Docker à l'aide de la commande suivante:
docker logs -f ${SAX_MODEL_SERVER_DOCKER_NAME}Point de contrôle du modèle:
Vous devez installer PyTorch et Transformers pour télécharger le point de contrôle GPT-J depuis EleutherAI:
pip3 install accelerate pip3 install torch pip3 install transformers
Pour convertir le point de contrôle en point de contrôle SAX, vous devez installer
paxml:pip3 install paxml==1.1.0
Ensuite, définissez la variable suivante:
>>PT_CHECKPOINT_PATH=./fine_tuned_pt_checkpoint
Téléchargez le point de contrôle PyTorch réglé sur
${PT_CHECKPOINT_PATH}, suivezhttps://github.com/mlcommons/inference/blob/master/language/gpt-j/README.md#download-gpt-j-modelet exécutez les commandes suivantes:ls ${PT_CHECKPOINT_PATH}Vous devriez obtenir la liste suivante:
added_tokens.json generation_config.json pytorch_model.bin.index.json pytorch_model-00001-of-00003.bin pytorch_model-00002-of-00003.bin pytorch_model-00003-of-00003.bin special_tokens_map.json trainer_state.json config.json merges.txt tokenizer_config.json vocab.json
Le script suivant convertit le point de contrôle GPT-J en point de contrôle SAX:
python3 -m convert_gptj_ckpt --base EleutherAI/gpt-j-6b --pax pax_6b wget https://raw.githubusercontent.com/google/saxml/main/saxml/tools/convert_gptj_ckpt.py python3 -m convert_gptj_ckpt --base ${PT_CHECKPOINT_PATH} --pax .Le contenu devrait être semblable à celui-ci:transformer.wte.weight (50401, 4096) transformer.h.0.ln_1.weight (4096,) transformer.h.0.ln_1.bias (4096,) transformer.h.0.attn.k_proj.weight (4096, 4096) . . . transformer.ln_f.weight (4096,) transformer.ln_f.bias (4096,) lm_head.weight (50401, 4096) lm_head.bias (50401,) Saving the pax model to . done
Une fois la conversion terminée, saisissez la commande suivante:
ls checkpoint_00000000/
Vous devriez obtenir la liste suivante:
metadate state
Vous devez créer un fichier commit_success et le placer dans les sous-répertoires suivants:
CHECKPOINT_PATH=gs://${SAX_DATA_STORAGE_BUCKET}/path/to/checkpoint_00000000 gsutil -m cp -r checkpoint_00000000 ${CHECKPOINT_PATH} touch commit_success.txt gsutil cp commit_success.txt ${CHECKPOINT_PATH}/ gsutil cp commit_success.txt ${CHECKPOINT_PATH}/metadata/ gsutil cp commit_success.txt ${CHECKPOINT_PATH}/state/Publier le modèle sur le cluster SAX
Vous pouvez maintenant publier GPT-J avec le point de contrôle converti à l'étape précédente.
MODEL_NAME=gptjtokenizedbf16bs32 MODEL_CONFIG_PATH=saxml.server.pax.lm.params.gptj.GPTJ4TokenizedBF16BS32 REPLICA=1
Pour publier le tag GPT-J (et les étapes suivantes), utilisez SSH pour vous connecter à votre VM TPU dans un troisième terminal:
docker run \ ${SAX_UTIL_IMAGE_URL} \ --sax_root=gs://${SAX_ADMIN_STORAGE_BUCKET}/sax-root \ publish \ ${SAX_CELL}/${MODEL_NAME} \ ${MODEL_CONFIG_PATH} \ ${CHECKPOINT_PATH} \ ${REPLICA}Vous constaterez une grande activité dans le journal Docker du serveur de modèles jusqu'à ce que vous voyiez une sortie semblable à celle-ci pour indiquer que le modèle a bien été chargé:
I0829 01:33:49.287459 139865140229696 servable_model.py:697] loading completed.
Générer des résultats d'inférence
Pour GPT-J, l'entrée et la sortie doivent être formatées en une chaîne d'ID de jeton séparée par des virgules. Vous devez tokeniser l'entrée de texte.
TEXT = ("Below is an instruction that describes a task, paired with " "an input that provides further context. Write a response that " "appropriately completes the request.\n\n### Instruction\:\nSummarize the " "following news article\:\n\n### Input\:\nMarch 10, 2015 . We're truly " "international in scope on Tuesday. We're visiting Italy, Russia, the " "United Arab Emirates, and the Himalayan Mountains. Find out who's " "attempting to circumnavigate the globe in a plane powered partially by the " "sun, and explore the mysterious appearance of craters in northern Asia. " "You'll also get a view of Mount Everest that was previously reserved for " "climbers. On this page you will find today's show Transcript and a place " "for you to request to be on the CNN Student News Roll Call. TRANSCRIPT . " "Click here to access the transcript of today's CNN Student News program. " "Please note that there may be a delay between the time when the video is " "available and when the transcript is published. CNN Student News is " "created by a team of journalists who consider the Common Core State " "Standards, national standards in different subject areas, and state " "standards when producing the show. ROLL CALL . For a chance to be " "mentioned on the next CNN Student News, comment on the bottom of this page " "with your school name, mascot, city and state. We will be selecting " "schools from the comments of the previous show. You must be a teacher or a " "student age 13 or older to request a mention on the CNN Student News Roll " "Call! Thank you for using CNN Student News!\n\n### Response\:")Vous pouvez obtenir la chaîne d'ID de jeton via le jeton EleutherAI/gpt-j-6b:
from transformers import GPT2Tokenizer tokenizer = GPT2Tokenizer.from_pretrained(EleutherAI/gpt-j-6b)
Tokeniser le texte d'entrée:
encoded_example = tokenizer(TEXT) input_ids = encoded_example.input_ids INPUT_STR = ",".join([str(input_id) for input_id in input_ids])
Vous pouvez vous attendre à une chaîne d'ID de jeton semblable à celle-ci:
>>> INPUT_STR '21106,318,281,12064,326,8477,257,4876,11,20312,351,281,5128,326,3769,2252,4732,13,19430,257,2882,326,20431,32543,262,2581,13,198,198,21017,46486,25,198,13065,3876,1096,262,1708,1705,2708,25,198,198,21017,23412,25,198,16192,838,11,1853,764,775,821,4988,3230,287,8354,319,3431,13,775,821,10013,8031,11,3284,11,262,1578,4498,24880,11,290,262,42438,22931,21124,13,9938,503,508,338,9361,284,2498,4182,615,10055,262,13342,287,257,6614,13232,12387,416,262,4252,11,290,7301,262,11428,5585,286,1067,8605,287,7840,7229,13,921,1183,635,651,257,1570,286,5628,41336,326,373,4271,10395,329,39311,13,1550,428,2443,345,481,1064,1909,338,905,42978,290,257,1295,329,345,284,2581,284,307,319,262,8100,13613,3000,8299,4889,13,48213,6173,46023,764,6914,994,284,1895,262,14687,286,1909,338,8100,13613,3000,1430,13,4222,3465,326,612,743,307,257,5711,1022,262,640,618,262,2008,318,1695,290,618,262,14687,318,3199,13,8100,13613,3000,318,2727,416,257,1074,286,9046,508,2074,262,8070,7231,1812,20130,11,2260,5423,287,1180,2426,3006,11,290,1181,5423,618,9194,262,905,13,15107,3069,42815,764,1114,257,2863,284,307,4750,319,262,1306,8100,13613,3000,11,2912,319,262,4220,286,428,2443,351,534,1524,1438,11,37358,11,1748,290,1181,13,775,481,307,17246,4266,422,262,3651,286,262,2180,905,13,921,1276,307,257,4701,393,257,3710,2479,1511,393,4697,284,2581,257,3068,319,262,8100,13613,3000,8299,4889,0,6952,345,329,1262,8100,13613,3000,0,198,198,21017,18261,25'
Pour générer un résumé de votre article:
docker run \ ${SAX_UTIL_IMAGE_URL} \ --sax_root=gs://${SAX_ADMIN_STORAGE_BUCKET}/sax-root \ lm.generate \ ${SAX_CELL}/${MODEL_NAME} \ ${INPUT_STR}Le résultat devrait ressembler à ceci:
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------+ | GENERATE | SCORE | +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------+ | 1212,2443,3407,262,905,42978,764,198,11041,262,42978,284,1037,2444,351,3555,35915,290,25818,764,198,2953,262,4220,286,262,2443,11,2912,329,257,2863,284,307,4750,319,8100,13613,3000,13,220,921,1276,307,257,4701,393,257,3710,2479,1511,393,4697,284,2581,257,3068,319,262,8100,13613,3000,8299,4889,13,50256 | -0.023136413 | | 1212,2443,3407,262,905,42978,764,198,11041,262,42978,284,1037,2444,351,3555,35915,290,25818,764,198,2953,262,4220,286,262,2443,11,2912,329,257,2863,284,307,4750,319,8100,13613,3000,13,220,921,1276,307,257,4701,393,257,3710,2479,1511,393,4697,284,2581,257,3068,319,262,8100,13613,3000,8299,4889,0,50256 | -0.91842502 | | 1212,2443,3407,262,905,42978,764,198,11041,262,42978,284,1037,2444,351,3555,35915,290,25818,764,198,2953,262,4220,286,262,2443,11,2912,329,257,2863,284,307,4750,319,8100,13613,3000,13,921,1276,307,257,4701,393,257,3710,2479,1511,393,4697,284,2581,257,3068,319,262,8100,13613,3000,8299,4889,13,50256 | -1.1726116 | | 1212,2443,3407,262,905,42978,764,198,11041,262,42978,284,1037,2444,351,3555,35915,290,25818,764,198,2953,262,4220,286,262,2443,11,2912,329,257,2863,284,307,4750,319,8100,13613,3000,13,220,921,1276,307,1511,393,4697,284,2581,257,3068,319,262,8100,13613,3000,8299,4889,13,50256 | -1.2472695 | +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------+
Pour détokeniser la chaîne d'ID des jetons de sortie:
output_token_ids = [int(token_id) for token_id in OUTPUT_STR.split(',')] OUTPUT_TEXT = tokenizer.decode(output_token_ids, skip_special_tokens=True)Vous pouvez vous attendre à ce que le texte détokenisé soit le suivant:
>>> OUTPUT_TEXT 'This page includes the show Transcript.\nUse the Transcript to help students with reading comprehension and vocabulary.\nAt the bottom of the page, comment for a chance to be mentioned on CNN Student News. You must be a teacher or a student age 13 or older to request a mention on the CNN Student News Roll Call.'
Nettoyez vos conteneurs Docker et vos buckets de stockage Cloud Storage.
Aperçu de la diffusion du modèle à hôtes multiples de 175 milliards
Certains des grands modèles de langage nécessitent une tranche de TPU multi-hôte, c'est-à-dire v5litepod-16 et versions ultérieures. Dans ce cas, tous les hôtes TPU à hôtes multiples devront disposer d'une copie d'un serveur de modèles SAX, et tous les serveurs de modèles fonctionnent comme un groupe de serveurs de modèles SAX pour diffuser le modèle volumineux sur une tranche de TPU multi-hôte.
Créer un cluster SAX
Vous pouvez suivre la même étape que celle consistant à créer un cluster SAX dans le tutoriel GPT-J pour créer un cluster SAX et un serveur d'administration SAX.
Si vous disposez déjà d'un cluster SAX, vous pouvez également lancer un serveur de modèle à hôtes multiples dans votre cluster SAX.
Lancer un serveur de modèle SAX à plusieurs hôtes dans un cluster SAX
Pour créer une tranche de TPU multi-hôte, utilisez la même commande que pour une tranche de TPU à hôte unique. Pour ce faire, spécifiez simplement le type d'accélérateur multi-hôte approprié:
ACCELERATOR_TYPE=v5litepod-32 ZONE=us-east1-c gcloud alpha 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} \ --reservedPour extraire l'image du serveur de modèles SAX vers tous les hôtes/nœuds de calcul TPU et les lancer, procédez comme suit:
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 docker pull ${SAX_MODEL_SERVER_IMAGE_URL} # Run model server docker run \ --privileged \ -it \ -d \ --rm \ --network host \ --name ${SAX_MODEL_SERVER_DOCKER_NAME} \ --env SAX_ROOT=gs://${SAX_ADMIN_STORAGE_BUCKET}/sax-root \ ${SAX_MODEL_SERVER_IMAGE_URL} \ --sax_cell=${SAX_CELL} \ --port=10001 \ --platform_chip=tpuv4 \ --platform_topology=1x1"Publier le modèle sur le cluster SAX
Cet exemple utilise un modèle LmCloudSpmd175B32Test:
MODEL_NAME=lmcloudspmd175b32test MODEL_CONFIG_PATH=saxml.server.pax.lm.params.lm_cloud.LmCloudSpmd175B32Test CHECKPOINT_PATH=None REPLICA=1
Pour publier le modèle de test, procédez comme suit:
docker run \ ${SAX_UTIL_IMAGE_URL} \ --sax_root=gs://${SAX_ADMIN_STORAGE_BUCKET}/sax-root \ publish \ ${SAX_CELL}/${MODEL_NAME} \ ${MODEL_CONFIG_PATH} \ ${CHECKPOINT_PATH} \ ${REPLICA}Générer des résultats d'inférence
docker run \ ${SAX_UTIL_IMAGE_URL} \ --sax_root=gs://${SAX_ADMIN_STORAGE_BUCKET}/sax-root \ lm.generate \ ${SAX_CELL}/${MODEL_NAME} \ "Q: Who is Harry Porter's mother? A\: "Étant donné que cet exemple utilise un modèle de test avec des pondérations aléatoires, le résultat peut ne pas être pertinent.
Effectuer un nettoyage
Arrêtez les conteneurs Docker:
docker stop ${SAX_ADMIN_SERVER_DOCKER_NAME} docker stop ${SAX_MODEL_SERVER_DOCKER_NAME}Supprimez le bucket de stockage administrateur Cloud Storage et tout bucket de stockage de données à l'aide de
gsutil, comme indiqué ci-dessous.gsutil rm -rf gs://${SAX_ADMIN_STORAGE_BUCKET} gsutil rm -rf gs://${SAX_DATA_STORAGE_BUCKET}
Profilage
Une fois l'inférence configurée, vous pouvez utiliser les profileurs pour analyser les performances et l'utilisation du TPU. Les références à certains documents liés au profilage sont présentées ci-dessous:
Assistance et commentaires
Tous vos commentaires sont les bienvenus ! Pour partager vos commentaires ou demander de l'aide, contactez-nous ou envoyez un e-mail à cloudtpu-preview-support@google.com.
Conditions d'utilisation
Toutes les informations que Google vous a fournies concernant cette Version preview sont confidentielles et soumises aux dispositions de confidentialité énoncées dans les Conditions d'utilisation de Google Cloud Platform (ou tout autre accord régissant votre utilisation de Google Cloud Platform).