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

Évoluer les charges de travail de ML à l'aide de Ray

Ce document explique comment exécuter des charges de travail de machine learning (ML) avec Ray et JAX sur des TPU. Il existe deux modes d'utilisation des TPU avec Ray : le mode axé sur l'appareil (PyTorch/XLA) et le mode axé sur l'hôte (JAX).

Ce document suppose que vous avez déjà configuré un environnement TPU. Pour en savoir plus, consultez les ressources suivantes:

Cloud TPU: configurer l'environnement Cloud TPU et gérer les ressources TPU
Google Kubernetes Engine (GKE): Déployez des charges de travail TPU dans GKE Autopilot ou Déployez des charges de travail TPU dans GKE Standard

Mode axé sur l'appareil (PyTorch/XLA)

Le mode axé sur l'appareil conserve une grande partie du style programmatique de PyTorch classique. Dans ce mode, vous ajoutez un type d'appareil XLA, qui fonctionne comme n'importe quel autre appareil PyTorch. Chaque processus interagit avec un seul appareil XLA.

Ce mode est idéal si vous connaissez déjà PyTorch avec des GPU et que vous souhaitez utiliser des abstractions de codage similaires.

Les sections suivantes décrivent comment exécuter une charge de travail PyTorch/XLA sur un ou plusieurs appareils sans utiliser Ray, puis comment exécuter la même charge de travail sur plusieurs hôtes à l'aide de Ray.

Créer un TPU

Créez des variables d'environnement pour les paramètres de création de TPU.

export PROJECT_ID=your-project-id
export TPU_NAME=your-tpu-name
export ZONE=europe-west4-b
export ACCELERATOR_TYPE=v5p-8
export RUNTIME_VERSION=v2-alpha-tpuv5

Descriptions des variables d'environnement

Variable	Description
`PROJECT_ID`	L'ID de votre Google Cloud projet. Utilisez un projet existant ou créez-en un.
`TPU_NAME`	Nom du TPU.
`ZONE`	Zone dans laquelle créer la VM TPU. Pour en savoir plus sur les zones compatibles, consultez la section Régions et zones de TPU.
`ACCELERATOR_TYPE`	Le type d'accélérateur spécifie la version et la taille du Cloud TPU que vous souhaitez créer. Pour en savoir plus sur les types d'accélérateurs compatibles avec chaque version de TPU, consultez la section Versions de TPU.
`RUNTIME_VERSION`	Version logicielle de Cloud TPU.

Utilisez la commande suivante pour créer une VM TPU v5p avec huit cœurs:

gcloud compute tpus tpu-vm create $TPU_NAME \
   --zone=$ZONE \
   --accelerator-type=$ACCELERATOR_TYPE  \
   --version=$RUNTIME_VERSION

Connectez-vous à la VM TPU à l'aide de la commande suivante:
```
gcloud compute tpus tpu-vm ssh $TPU_NAME --zone=$ZONE
```

Si vous utilisez GKE, consultez le guide KubeRay sur GKE pour en savoir plus sur la configuration.

Configuration requise

Exécutez les commandes suivantes sur votre VM TPU pour installer les dépendances requises:

Enregistrez le code suivant dans un fichier. Par exemple, requirements.txt.

--find-links https://storage.googleapis.com/libtpu-releases/index.html
--find-links https://storage.googleapis.com/libtpu-wheels/index.html
torch~=2.6.0
torch_xla[tpu]~=2.6.0
ray[default]==2.40.0

Pour installer les dépendances requises, exécutez la commande suivante:
```
pip install -r requirements.txt
```

Si vous exécutez votre charge de travail sur GKE, nous vous recommandons de créer un Dockerfile qui installe les dépendances requises. Pour obtenir un exemple, consultez la section Exécuter votre charge de travail sur des nœuds de tranche TPU dans la documentation GKE.

Exécuter une charge de travail PyTorch/XLA sur un seul appareil

L'exemple suivant montre comment créer un tenseur XLA sur un seul appareil, qui est une puce TPU. Cela ressemble à la façon dont PyTorch gère les autres types d'appareils.

Enregistrez l'extrait de code suivant dans un fichier. Par exemple, workload.py.
```
import torch
import torch_xla
import torch_xla.core.xla_model as xm

t = torch.randn(2, 2, device=xm.xla_device())
print(t.device)
print(t)
```
L'instruction d'importation import torch_xla initialise PyTorch/XLA, et la fonction xm.xla_device() renvoie l'appareil XLA actuel, une puce TPU.
Définissez la variable d'environnement PJRT_DEVICE sur TPU.
```
export PJRT_DEVICE=TPU
```
Exécutez le script.
```
python workload.py
```
La sortie doit ressembler à ce qui suit. Assurez-vous que la sortie indique que l'appareil XLA a été détecté.
```
xla:0
tensor([[ 0.6220, -1.4707],
        [-1.2112,  0.7024]], device='xla:0')
```

Exécuter PyTorch/XLA sur plusieurs appareils

Modifiez l'extrait de code de la section précédente pour qu'il s'exécute sur plusieurs appareils.

import torch
import torch_xla
import torch_xla.core.xla_model as xm

def _mp_fn(index):
    t = torch.randn(2, 2, device=xm.xla_device())
    print(t.device)
    print(t)

if __name__ == '__main__':
    torch_xla.launch(_mp_fn, args=())

Exécutez le script.

python workload.py

Si vous exécutez l'extrait de code sur un TPU v5p-8, le résultat ressemble à ceci:

xla:0
xla:0
xla:0
tensor([[ 1.2309,  0.9896],
        [ 0.5820, -1.2950]], device='xla:0')
xla:0
tensor([[ 1.2309,  0.9896],
        [ 0.5820, -1.2950]], device='xla:0')
tensor([[ 1.2309,  0.9896],
        [ 0.5820, -1.2950]], device='xla:0')
tensor([[ 1.2309,  0.9896],
        [ 0.5820, -1.2950]], device='xla:0')

torch_xla.launch() accepte deux arguments: une fonction et une liste de paramètres. Il crée un processus pour chaque appareil XLA disponible et appelle la fonction spécifiée dans les arguments. Dans cet exemple, quatre appareils TPU sont disponibles. torch_xla.launch() crée donc quatre processus et appelle _mp_fn() sur chaque appareil. Chaque processus n'a accès qu'à un seul appareil. Par conséquent, chaque appareil a l'indice 0, et xla:0 est imprimé pour tous les processus.

Exécuter PyTorch/XLA sur plusieurs hôtes avec Ray

Les sections suivantes montrent comment exécuter le même extrait de code sur une tranche TPU multi-hôte plus importante. Pour en savoir plus sur l'architecture TPU multi-hôte, consultez la section Architecture du système.

Dans cet exemple, vous allez configurer manuellement Ray. Si vous savez déjà configurer Ray, vous pouvez passer à la dernière section, Exécuter une charge de travail Ray. Pour en savoir plus sur la configuration de Ray pour un environnement de production, consultez les ressources suivantes:

Créer une VM TPU multi-hôte

Créez des variables d'environnement pour les paramètres de création de TPU.

export PROJECT_ID=your-project-id
export TPU_NAME=your-tpu-name
export ZONE=europe-west4-b
export ACCELERATOR_TYPE=v5p-16
export RUNTIME_VERSION=v2-alpha-tpuv5

Descriptions des variables d'environnement

Variable	Description
`PROJECT_ID`	L'ID de votre Google Cloud projet. Utilisez un projet existant ou créez-en un.
`TPU_NAME`	Nom du TPU.
`ZONE`	Zone dans laquelle créer la VM TPU. Pour en savoir plus sur les zones compatibles, consultez la section Régions et zones de TPU.
`ACCELERATOR_TYPE`	Le type d'accélérateur spécifie la version et la taille du Cloud TPU que vous souhaitez créer. Pour en savoir plus sur les types d'accélérateurs compatibles avec chaque version de TPU, consultez la section Versions de TPU.
`RUNTIME_VERSION`	Version logicielle de Cloud TPU.

Créez un TPU v5p multi-hôte avec deux hôtes (un v5p-16, avec quatre puces TPU sur chaque hôte) à l'aide de la commande suivante:

gcloud compute tpus tpu-vm create $TPU_NAME \
   --zone=$ZONE \
   --accelerator-type=$ACCELERATOR_TYPE \
   --version=$RUNTIME_VERSION

Configurer Ray

Un TPU v5p-16 comporte deux hôtes TPU, chacun avec quatre puces TPU. Dans cet exemple, vous allez démarrer le nœud principal Ray sur un hôte et ajouter le deuxième hôte en tant que nœud de travail au cluster Ray.

Connectez-vous au premier hôte à l'aide de SSH.

gcloud compute tpus tpu-vm ssh $TPU_NAME --zone=$ZONE --worker=0

Installez les dépendances avec le même fichier d'exigences que dans la section Exigences d'installation.
```
pip install -r requirements.txt
```

Démarrez le processus Ray.

ray start --head --port=6379

La sortie ressemble à ceci :

Enable usage stats collection? This prompt will auto-proceed in 10 seconds to avoid blocking cluster startup. Confirm [Y/n]: y
Usage stats collection is enabled. To disable this, add `--disable-usage-stats` to the command that starts the cluster, or run the following command: `ray disable-usage-stats` before starting the cluster. See https://docs.ray.io/en/master/cluster/usage-stats.html for more details.

Local node IP: 10.130.0.76

--------------------
Ray runtime started.
--------------------

Next steps
To add another node to this Ray cluster, run
    ray start --address='10.130.0.76:6379'

To connect to this Ray cluster:
    import ray
    ray.init()

To terminate the Ray runtime, run
    ray stop

To view the status of the cluster, use
    ray status

Cet hôte TPU est désormais le nœud principal de Ray. Notez les lignes qui montrent comment ajouter un autre nœud au cluster Ray, comme suit:

To add another node to this Ray cluster, run
    ray start --address='10.130.0.76:6379'

Vous utiliserez cette commande dans une prochaine étape.

Vérifiez l'état du cluster Ray:

ray status

La sortie ressemble à ceci :

======== Autoscaler status: 2025-01-14 22:03:39.385610 ========
Node status
---------------------------------------------------------------
Active:
1 node_bc0c62819ddc0507462352b76cc06b462f0e7f4898a77e5133c16f79
Pending:
(no pending nodes)
Recent failures:
(no failures)

Resources
---------------------------------------------------------------
Usage:
0.0/208.0 CPU
0.0/4.0 TPU
0.0/1.0 TPU-v5p-16-head
0B/268.44GiB memory
0B/119.04GiB object_store_memory
0.0/1.0 your-tpu-name

Demands:
(no resource demands)

Le cluster ne contient que quatre TPU (0.0/4.0 TPU), car vous n'avez ajouté que le nœud principal jusqu'à présent.

Maintenant que le nœud principal est en cours d'exécution, vous pouvez ajouter le deuxième hôte au cluster.

Connectez-vous au deuxième hôte à l'aide de SSH.

gcloud compute tpus tpu-vm ssh $TPU_NAME --zone=$ZONE --worker=1

Installez les dépendances avec le même fichier d'exigences que dans la section Exigences d'installation.
```
pip install -r requirements.txt
```

Démarrez le processus Ray. Pour ajouter ce nœud au cluster Ray existant, utilisez la commande de la sortie de la commande ray start. Veillez à remplacer l'adresse IP et le port dans la commande suivante:

ray start --address='10.130.0.76:6379'

La sortie ressemble à ceci :

Local node IP: 10.130.0.80
[2025-01-14 22:30:07,397 W 75572 75572] global_state_accessor.cc:463: Retrying to get node with node ID 35f9ac0675c91429805cdc1b97c3713422d97eee783ccb0c0304f5c1

--------------------
Ray runtime started.
--------------------

To terminate the Ray runtime, run
ray stop

Vérifiez à nouveau l'état de Ray:

ray status

La sortie ressemble à ceci :

======== Autoscaler status: 2025-01-14 22:45:21.485617 ========
Node status
---------------------------------------------------------------
Active:
1 node_bc0c62819ddc0507462352b76cc06b462f0e7f4898a77e5133c16f79
1 node_35f9ac0675c91429805cdc1b97c3713422d97eee783ccb0c0304f5c1
Pending:
(no pending nodes)
Recent failures:
(no failures)

Resources
---------------------------------------------------------------
Usage:
0.0/416.0 CPU
0.0/8.0 TPU
0.0/1.0 TPU-v5p-16-head
0B/546.83GiB memory
0B/238.35GiB object_store_memory
0.0/2.0 your-tpu-name

Demands:
(no resource demands)

Le deuxième hôte TPU est désormais un nœud du cluster. La liste des ressources disponibles affiche désormais huit TPU (0.0/8.0 TPU).

Exécuter une charge de travail Ray

Modifiez l'extrait de code pour qu'il s'exécute sur le cluster Ray:

import os
import torch
import torch_xla
import torch_xla.core.xla_model as xm
import ray

import torch.distributed as dist
import torch_xla.runtime as xr
from torch_xla._internal import pjrt

# Defines the local PJRT world size, the number of processes per host.
LOCAL_WORLD_SIZE = 4
# Defines the number of hosts in the Ray cluster.
NUM_OF_HOSTS = 4
GLOBAL_WORLD_SIZE = LOCAL_WORLD_SIZE * NUM_OF_HOSTS

def init_env():
    local_rank = int(os.environ['TPU_VISIBLE_CHIPS'])

    pjrt.initialize_multiprocess(local_rank, LOCAL_WORLD_SIZE)
    xr._init_world_size_ordinal()

# This decorator signals to Ray that the `print_tensor()` function should be run on a single TPU chip.
@ray.remote(resources={"TPU": 1})
def print_tensor():
    # Initializes the runtime environment on each Ray worker. Equivalent to
    # the `torch_xla.launch call` in the Run PyTorch/XLA on multiple devices section.
    init_env()

    t = torch.randn(2, 2, device=xm.xla_device())
    print(t.device)
    print(t)

ray.init()

# Uses Ray to dispatch the function call across available nodes in the cluster.
tasks = [print_tensor.remote() for _ in range(GLOBAL_WORLD_SIZE)]
ray.get(tasks)

ray.shutdown()

Exécutez le script sur le nœud principal de Ray. Remplacez ray-workload.py par le chemin d'accès à votre script.

python ray-workload.py

La sortie ressemble à ceci :

WARNING:root:libtpu.so and TPU device found. Setting PJRT_DEVICE=TPU.
xla:0
xla:0
xla:0
xla:0
xla:0
tensor([[ 0.6220, -1.4707],
        [-1.2112,  0.7024]], device='xla:0')
tensor([[ 0.6220, -1.4707],
        [-1.2112,  0.7024]], device='xla:0')
xla:0
xla:0
tensor([[ 0.6220, -1.4707],
        [-1.2112,  0.7024]], device='xla:0')
tensor([[ 0.6220, -1.4707],
        [-1.2112,  0.7024]], device='xla:0')
tensor([[ 0.6220, -1.4707],
        [-1.2112,  0.7024]], device='xla:0')
tensor([[ 0.6220, -1.4707],
        [-1.2112,  0.7024]], device='xla:0')
tensor([[ 0.6220, -1.4707],
        [-1.2112,  0.7024]], device='xla:0')
xla:0
tensor([[ 0.6220, -1.4707],
        [-1.2112,  0.7024]], device='xla:0')

La sortie indique que la fonction a bien été appelée sur chaque appareil XLA (huit appareils dans cet exemple) de la tranche TPU multi-hôte.

Mode hôte centré (JAX)

Les sections suivantes décrivent le mode hôte centré avec JAX. JAX utilise un paradigme de programmation fonctionnelle et prend en charge la sémantique SPMD (single program, multiple data) de niveau supérieur. Au lieu de laisser chaque processus interagir avec un seul appareil XLA, le code JAX est conçu pour fonctionner simultanément sur plusieurs appareils d'un même hôte.

JAX est conçu pour le calcul hautes performances et peut utiliser efficacement les TPU pour l'entraînement et l'inférence à grande échelle. Ce mode est idéal si vous connaissez les concepts de programmation fonctionnelle afin de pouvoir exploiter tout le potentiel de JAX.

Ces instructions supposent que vous avez déjà configuré un environnement Ray et TPU, y compris un environnement logiciel qui inclut JAX et d'autres packages associés. Pour créer un cluster TPU Ray, suivez les instructions de la section Démarrer Google Cloud un cluster GKE avec des TPU pour KubeRay. Pour en savoir plus sur l'utilisation des TPU avec KubeRay, consultez Utiliser des TPU avec KubeRay.

Exécuter une charge de travail JAX sur un TPU à hôte unique

L'exemple de script suivant montre comment exécuter une fonction JAX sur un cluster Ray avec un TPU à hôte unique, tel qu'un v6e-4. Si vous disposez d'un TPU multi-hôte, ce script cesse de répondre en raison du modèle d'exécution multicontrôleur de JAX. Pour en savoir plus sur l'exécution de Ray sur un TPU multi-hôte, consultez Exécuter une charge de travail JAX sur un TPU multi-hôte.

Créez des variables d'environnement pour les paramètres de création de TPU.

export PROJECT_ID=your-project-id
export TPU_NAME=your-tpu-name
export ZONE=europe-west4-a
export ACCELERATOR_TYPE=v6e-4
export RUNTIME_VERSION=v2-alpha-tpuv6e

Descriptions des variables d'environnement

Variable	Description
`PROJECT_ID`	L'ID de votre Google Cloud projet. Utilisez un projet existant ou créez-en un.
`TPU_NAME`	Nom du TPU.
`ZONE`	Zone dans laquelle créer la VM TPU. Pour en savoir plus sur les zones compatibles, consultez la section Régions et zones de TPU.
`ACCELERATOR_TYPE`	Le type d'accélérateur spécifie la version et la taille du Cloud TPU que vous souhaitez créer. Pour en savoir plus sur les types d'accélérateurs compatibles avec chaque version de TPU, consultez la section Versions de TPU.
`RUNTIME_VERSION`	Version logicielle de Cloud TPU.

Utilisez la commande suivante pour créer une VM TPU v6e avec quatre cœurs:

gcloud compute tpus tpu-vm create $TPU_NAME \
   --zone=$ZONE \
   --accelerator-type=$ACCELERATOR_TYPE  \
   --version=$RUNTIME_VERSION

Connectez-vous à la VM TPU à l'aide de la commande suivante:
```
gcloud compute tpus tpu-vm ssh $TPU_NAME --zone=$ZONE
```

Installez JAX et Ray sur votre TPU.

pip install ray jax[tpu] -f https://storage.googleapis.com/jax-releases/libtpu_releases.html

Enregistrez le code suivant dans un fichier. Par exemple, ray-jax-single-host.py.
```
import ray
import jax

@ray.remote(resources={"TPU": 4})
def my_function() -> int:
    return jax.device_count()

h = my_function.remote()
print(ray.get(h)) # => 4
```
Si vous avez l'habitude d'exécuter Ray avec des GPU, vous remarquerez quelques différences clés lorsque vous utiliserez des TPU:
- Au lieu de définir num_gpus, spécifiez TPU en tant que ressource personnalisée et définissez le nombre de puces TPU.
- Spécifiez le TPU à l'aide du nombre de puces par nœud de travail Ray. Par exemple, si vous utilisez un v6e-4, l'exécution d'une fonction distante avec TPU défini sur 4 consomme l'hôte TPU entier.
- Cela diffère de la manière dont les GPU s'exécutent généralement, avec un processus par hôte. Il est déconseillé de définir TPU sur un nombre autre que 4.
  - Exception: Si vous disposez d'un v6e-8 ou d'un v5litepod-8 pour un seul hôte, vous devez définir cette valeur sur 8.
Exécutez le script.
```
python ray-jax-single-host.py
```

Exécuter une charge de travail JAX sur un TPU multi-hôte

L'exemple de script suivant montre comment exécuter une fonction JAX sur un cluster Ray avec un TPU multi-hôte. L'exemple de script utilise une version v6e-16.

Créez des variables d'environnement pour les paramètres de création de TPU.

export PROJECT_ID=your-project-id
export TPU_NAME=your-tpu-name
export ZONE=europe-west4-a
export ACCELERATOR_TYPE=v6e-16
export RUNTIME_VERSION=v2-alpha-tpuv6e

Descriptions des variables d'environnement

Variable	Description
`PROJECT_ID`	L'ID de votre Google Cloud projet. Utilisez un projet existant ou créez-en un.
`TPU_NAME`	Nom du TPU.
`ZONE`	Zone dans laquelle créer la VM TPU. Pour en savoir plus sur les zones compatibles, consultez la section Régions et zones de TPU.
`ACCELERATOR_TYPE`	Le type d'accélérateur spécifie la version et la taille du Cloud TPU que vous souhaitez créer. Pour en savoir plus sur les types d'accélérateurs compatibles avec chaque version de TPU, consultez la section Versions de TPU.
`RUNTIME_VERSION`	Version logicielle de Cloud TPU.

Utilisez la commande suivante pour créer une VM TPU v6e avec 16 cœurs:

gcloud compute tpus tpu-vm create $TPU_NAME \
   --zone=$ZONE \
   --accelerator-type=$ACCELERATOR_TYPE  \
   --version=$RUNTIME_VERSION

Installez JAX et Ray sur tous les nœuds de calcul TPU.

gcloud compute tpus tpu-vm ssh $TPU_NAME \
   --zone=$ZONE \
   --worker=all \
   --command="pip install ray jax[tpu] -f https://storage.googleapis.com/jax-releases/libtpu_releases.html"

Enregistrez le code suivant dans un fichier. Par exemple, ray-jax-multi-host.py.
```
import ray
import jax

@ray.remote(resources={"TPU": 4})
def my_function() -> int:
    return jax.device_count()

ray.init()
num_tpus = ray.available_resources()["TPU"]
num_hosts = int(num_tpus) # 4
h = [my_function.remote() for _ in range(num_hosts)]
print(ray.get(h)) # [16, 16, 16, 16]
```
Si vous avez l'habitude d'exécuter Ray avec des GPU, vous constaterez quelques différences clés lorsque vous utiliserez des TPU:
- Comme pour les charges de travail PyTorch sur les GPU :
  - Les charges de travail JAX sur les TPU s'exécutent de manière multicontrôleur, programme unique, données multiples (SPMD).
  - Les collectifs entre les appareils sont gérés par le framework de machine learning.
- Contrairement aux charges de travail PyTorch sur les GPU, JAX dispose d'une vue globale des appareils disponibles dans le cluster.

Copiez le script sur tous les nœuds de calcul TPU.

gcloud compute tpus tpu-vm scp ray-jax-multi-host.py $TPU_NAME: --zone=$ZONE --worker=all

Exécutez le script.

gcloud compute tpus tpu-vm ssh $TPU_NAME \
   --zone=$ZONE \
   --worker=all \
   --command="python ray-jax-multi-host.py"

Exécuter une charge de travail JAX Multislice

Multislice vous permet d'exécuter des charges de travail couvrant plusieurs tranches de TPU dans un seul pod TPU ou dans plusieurs pods sur le réseau du centre de données.

Vous pouvez utiliser le package ray-tpu pour simplifier les interactions de Ray avec les tranches de TPU.

Installez ray-tpu à l'aide de pip.

pip install ray-tpu

Pour en savoir plus sur l'utilisation du package ray-tpu, consultez la section Premiers pas dans le dépôt GitHub. Pour obtenir un exemple d'utilisation de Multislice, consultez la section Exécuter sur Multislice.

Orchestrer des charges de travail à l'aide de Ray et de MaxText

Pour en savoir plus sur l'utilisation de Ray avec MaxText, consultez Exécuter un job d'entraînement avec MaxText.

Ressources TPU et Ray

Ray traite les TPU différemment des GPU pour tenir compte de la différence d'utilisation. Dans l'exemple suivant, il y a neuf nœuds Ray au total:

Le nœud principal Ray s'exécute sur une VM n1-standard-16.
Les nœuds de calcul Ray s'exécutent sur deux TPU v6e-16. Chaque TPU constitue quatre nœuds de calcul.

$ ray status
======== Autoscaler status: 2024-10-17 09:30:00.854415 ========
Node status
---------------------------------------------------------------
Active:
 1 node_e54a65b81456cee40fcab16ce7b96f85406637eeb314517d9572dab2
 1 node_9a8931136f8d2ab905b07d23375768f41f27cc42f348e9f228dcb1a2
 1 node_c865cf8c0f7d03d4d6cae12781c68a840e113c6c9b8e26daeac23d63
 1 node_435b1f8f1fbcd6a4649c09690915b692a5bac468598e9049a2fac9f1
 1 node_3ed19176e9ecc2ac240c818eeb3bd4888fbc0812afebabd2d32f0a91
 1 node_6a88fe1b74f252a332b08da229781c3c62d8bf00a5ec2b90c0d9b867
 1 node_5ead13d0d60befd3a7081ef8b03ca0920834e5c25c376822b6307393
 1 node_b93cb79c06943c1beb155d421bbd895e161ba13bccf32128a9be901a
 1 node_9072795b8604ead901c5268ffcc8cc8602c662116ac0a0272a7c4e04
Pending:
 (no pending nodes)
Recent failures:
 (no failures)

Resources
---------------------------------------------------------------
Usage:
 0.0/727.0 CPU
 0.0/32.0 TPU
 0.0/2.0 TPU-v6e-16-head
 0B/5.13TiB memory
 0B/1.47TiB object_store_memory
 0.0/4.0 tpu-group-0
 0.0/4.0 tpu-group-1

Demands:
 (no resource demands)

Descriptions des champs d'utilisation des ressources:

CPU: nombre total de processeurs disponibles dans le cluster.
TPU: nombre de puces TPU dans le cluster.
TPU-v6e-16-head: identifiant spécial de la ressource qui correspond au nœud de calcul 0 d'une tranche TPU. Cela est important pour accéder à des tranches de TPU individuelles.
memory: mémoire de tas de nœuds de calcul utilisée par votre application.
object_store_memory: mémoire utilisée lorsque votre application crée des objets dans le magasin d'objets à l'aide de ray.put et lorsqu'elle renvoie des valeurs à partir de fonctions distantes.
tpu-group-0 et tpu-group-1: identifiants uniques des tranches de TPU individuelles. Cela est important pour exécuter des tâches sur des tranches. Ces champs sont définis sur 4, car il y a quatre hôtes par tranche de TPU dans un v6e-16.