Esta página se ha traducido con Cloud Translation API.

Escalar cargas de trabajo de aprendizaje automático con Ray

En este documento se explica cómo ejecutar cargas de trabajo de aprendizaje automático (ML) con Ray y JAX en TPUs. Hay dos modos diferentes para usar las TPUs con Ray: Modo centrado en el dispositivo (PyTorch/XLA) y Modo centrado en el host (JAX).

En este documento se da por hecho que ya has configurado un entorno de TPU. Para obtener más información, consulta los siguientes recursos:

TPU de Cloud: configurar el entorno de TPU de Cloud y gestionar los recursos de TPU
Google Kubernetes Engine (GKE): Despliega cargas de trabajo de TPUs en Autopilot de GKE o Despliega cargas de trabajo de TPUs en GKE Standard

Modo centrado en el dispositivo (PyTorch/XLA)

El modo centrado en el dispositivo conserva gran parte del estilo de programación de PyTorch clásico. En este modo, se añade un nuevo tipo de dispositivo XLA, que funciona como cualquier otro dispositivo PyTorch. Cada proceso individual interactúa con un dispositivo XLA.

Este modo es ideal si ya conoces PyTorch con GPUs y quieres usar abstracciones de codificación similares.

En las siguientes secciones se describe cómo ejecutar una carga de trabajo de PyTorch/XLA en uno o varios dispositivos sin usar Ray y, a continuación, cómo ejecutar la misma carga de trabajo en varios hosts con Ray.

Crear una TPU

Crea variables de entorno para los parámetros de creación 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

Descripciones de las variables de entorno

Variable	Descripción
`PROJECT_ID`	El ID de tu proyecto Google Cloud . Usa un proyecto que ya tengas o crea uno.
`TPU_NAME`	El nombre de la TPU.
`ZONE`	La zona en la que se creará la VM de TPU. Para obtener más información sobre las zonas admitidas, consulta Regiones y zonas de TPU.
`ACCELERATOR_TYPE`	El tipo de acelerador especifica la versión y el tamaño de la TPU de Cloud que quieres crear. Para obtener más información sobre los tipos de aceleradores compatibles con cada versión de TPU, consulta Versiones de TPU.
`RUNTIME_VERSION`	La versión de software de la TPU de Cloud.

Usa el siguiente comando para crear una VM de TPU v5p con 8 núcleos:

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

Conéctate a la VM de TPU con el siguiente comando:

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

Si usas GKE, consulta la guía de KubeRay en GKE para obtener información sobre la configuración.

Requisitos de instalación

Ejecuta los siguientes comandos en tu VM de TPU para instalar las dependencias necesarias:

Guarda lo siguiente en un archivo. Por ejemplo, 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

Para instalar las dependencias necesarias, ejecuta el siguiente comando:
```
pip install -r requirements.txt
```

Si ejecutas tu carga de trabajo en GKE, te recomendamos que crees un Dockerfile que instale las dependencias necesarias. Por ejemplo, consulta Ejecutar tu carga de trabajo en nodos de segmento de TPU en la documentación de GKE.

Ejecutar una carga de trabajo de PyTorch/XLA en un solo dispositivo

En el siguiente ejemplo se muestra cómo crear un tensor XLA en un solo dispositivo, que es un chip TPU. Es similar a la forma en que PyTorch gestiona otros tipos de dispositivos.

Guarda el siguiente fragmento de código en un archivo. Por ejemplo, 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)
```
La instrucción de importación import torch_xla inicializa PyTorch/XLA y la función xm.xla_device() devuelve el dispositivo XLA actual, un chip TPU.
Define la variable de entorno PJRT_DEVICE como TPU.
```
export PJRT_DEVICE=TPU
```
Ejecuta la secuencia de comandos.
```
python workload.py
```
La salida tiene un aspecto similar al siguiente. Asegúrate de que el resultado indique que se ha encontrado el dispositivo XLA.
```
xla:0
tensor([[ 0.6220, -1.4707],
        [-1.2112,  0.7024]], device='xla:0')
```

Ejecutar PyTorch/XLA en varios dispositivos

Actualiza el fragmento de código de la sección anterior para que se ejecute en varios dispositivos.

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=())

Ejecuta la secuencia de comandos.

python workload.py

Si ejecutas el fragmento de código en una TPU v5p-8, el resultado será similar al siguiente:

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() toma dos argumentos: una función y una lista de parámetros. Crea un proceso para cada dispositivo XLA disponible y llama a la función especificada en los argumentos. En este ejemplo, hay 4 dispositivos TPU disponibles, por lo que torch_xla.launch() crea 4 procesos y llama a _mp_fn() en cada dispositivo. Cada proceso solo tiene acceso a un dispositivo, por lo que cada dispositivo tiene el índice 0 y se imprime xla:0 para todos los procesos.

Ejecutar PyTorch/XLA en varios hosts con Ray

En las siguientes secciones se muestra cómo ejecutar el mismo fragmento de código en un segmento de TPU de varios hosts más grande. Para obtener más información sobre la arquitectura de TPU de varios hosts, consulta Arquitectura del sistema.

En este ejemplo, configurarás Ray manualmente. Si ya sabes cómo configurar Ray, puedes ir directamente a la última sección, Ejecutar una carga de trabajo de Ray. Para obtener más información sobre cómo configurar Ray en un entorno de producción, consulta los siguientes recursos:

Iniciar clústeres de Ray
Iniciar un clúster de GKE con TPUs para KubeRay Google Cloud

Crear una VM de TPU de varios hosts

Crea variables de entorno para los parámetros de creación 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

Descripciones de las variables de entorno

Variable	Descripción
`PROJECT_ID`	El ID de tu proyecto Google Cloud . Usa un proyecto que ya tengas o crea uno.
`TPU_NAME`	El nombre de la TPU.
`ZONE`	La zona en la que se creará la VM de TPU. Para obtener más información sobre las zonas admitidas, consulta Regiones y zonas de TPU.
`ACCELERATOR_TYPE`	El tipo de acelerador especifica la versión y el tamaño de la TPU de Cloud que quieres crear. Para obtener más información sobre los tipos de aceleradores compatibles con cada versión de TPU, consulta Versiones de TPU.
`RUNTIME_VERSION`	La versión de software de la TPU de Cloud.

Crea una TPU v5p de varios hosts con 2 hosts (una v5p-16, con 4 chips de TPU en cada host) mediante el siguiente comando:

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

Configurar Ray

Una TPU v5p-16 tiene 2 hosts de TPU, cada uno con 4 chips de TPU. En este ejemplo, iniciarás el nodo principal de Ray en un host y añadirás el segundo host como nodo de trabajador al clúster de Ray.

Conéctate al primer host mediante SSH.

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

Instala las dependencias con el mismo archivo de requisitos que en la sección Instalar requisitos.
```
pip install -r requirements.txt
```

Inicia el proceso de Ray.

ray start --head --port=6379

El resultado es similar al siguiente:

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

Este host de TPU ahora es el nodo principal de Ray. Anota las líneas que muestran cómo añadir otro nodo al clúster de Ray, como las siguientes:

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

Usarás este comando en un paso posterior.

Comprueba el estado del clúster de Ray:

ray status

El resultado es similar al siguiente:

======== 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)

El clúster solo contiene 4 TPUs (0.0/4.0 TPU) porque solo has añadido el nodo principal hasta ahora.

Ahora que el nodo principal está en funcionamiento, puedes añadir el segundo host al clúster.

Conéctate al segundo host mediante SSH.

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

Instala las dependencias con el mismo archivo de requisitos que en la sección Instalar requisitos.
```
pip install -r requirements.txt
```

Inicia el proceso de Ray. Para añadir este nodo al clúster de Ray, usa el comando de la salida del comando ray start. Asegúrate de sustituir la dirección IP y el puerto en el siguiente comando:

ray start --address='10.130.0.76:6379'

El resultado es similar al siguiente:

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

Vuelve a comprobar el estado de Ray:

ray status

El resultado es similar al siguiente:

======== 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)

El segundo host de TPU ahora es un nodo del clúster. En la lista de recursos disponibles ahora se muestran 8 TPUs (0.0/8.0 TPU).

Ejecutar una carga de trabajo de Ray

Actualiza el fragmento de código para que se ejecute en el clúster de 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()

Ejecuta la secuencia de comandos en el nodo principal de Ray. Sustituye ray-workload.py por la ruta a tu secuencia de comandos.

python ray-workload.py

El resultado es similar al siguiente:

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')

El resultado indica que la función se ha llamado correctamente en cada dispositivo XLA (8 dispositivos en este ejemplo) de la porción de TPU multihost.

Modo centrado en el host (JAX)

En las siguientes secciones se describe el modo centrado en el host con JAX. JAX usa un paradigma de programación funcional y admite semánticas de un solo programa y varios datos (SPMD) de nivel superior. En lugar de que cada proceso interactúe con un solo dispositivo XLA, el código JAX está diseñado para funcionar en varios dispositivos de un solo host simultáneamente.

JAX se ha diseñado para la computación de alto rendimiento y puede utilizar las TPUs de forma eficiente para el entrenamiento y la inferencia a gran escala. Este modo es ideal si conoces los conceptos de programación funcional para aprovechar todo el potencial de JAX.

En estas instrucciones se da por supuesto que ya tienes configurado un entorno de Ray y TPU, incluido un entorno de software que incluye JAX y otros paquetes relacionados. Para crear un clúster de TPU de Ray, sigue las instrucciones de Iniciar un clúster de GKE con TPUs para KubeRay Google Cloud . Para obtener más información sobre cómo usar TPUs con KubeRay, consulta Usar TPUs con KubeRay.

Ejecutar una carga de trabajo de JAX en una TPU de un solo host

La siguiente secuencia de comandos de ejemplo muestra cómo ejecutar una función de JAX en un clúster de Ray con una TPU de un solo host, como una v6e-4. Si tienes una TPU multihost, esta secuencia de comandos dejará de responder debido al modelo de ejecución multicontrolador de JAX. Para obtener más información sobre cómo ejecutar Ray en una TPU de varios hosts, consulta Ejecutar una carga de trabajo de JAX en una TPU de varios hosts.

Crea variables de entorno para los parámetros de creación 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

Descripciones de las variables de entorno

Variable	Descripción
`PROJECT_ID`	El ID de tu proyecto Google Cloud . Usa un proyecto que ya tengas o crea uno.
`TPU_NAME`	El nombre de la TPU.
`ZONE`	La zona en la que se creará la VM de TPU. Para obtener más información sobre las zonas admitidas, consulta Regiones y zonas de TPU.
`ACCELERATOR_TYPE`	El tipo de acelerador especifica la versión y el tamaño de la TPU de Cloud que quieres crear. Para obtener más información sobre los tipos de aceleradores compatibles con cada versión de TPU, consulta Versiones de TPU.
`RUNTIME_VERSION`	La versión de software de la TPU de Cloud.

Usa el siguiente comando para crear una VM de TPU v6e con 4 núcleos:

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

Conéctate a la VM de TPU con el siguiente comando:

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

Instala JAX y Ray en tu TPU.

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

Guarda el siguiente código en un archivo. Por ejemplo, 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 estás acostumbrado a ejecutar Ray con GPUs, hay algunas diferencias clave al usar TPUs:
- En lugar de definir num_gpus, especifica TPU como un recurso personalizado y define el número de chips de TPU.
- Especifica la TPU mediante el número de chips por nodo de trabajador de Ray. Por ejemplo, si usas una v6e-4 y ejecutas una función remota con TPU configurado en 4, se consumirá todo el host de la TPU.
- Esto es diferente de cómo se suelen ejecutar las GPUs, con un proceso por host. No se recomienda asignar a TPU un número que no sea 4.
  - Excepción: Si tienes un solo host v6e-8 o v5litepod-8, debes asignar el valor 8.
Ejecuta la secuencia de comandos.
```
python ray-jax-single-host.py
```

Ejecutar una carga de trabajo de JAX en una TPU de varios hosts

El siguiente script de ejemplo muestra cómo ejecutar una función de JAX en un clúster de Ray con una TPU multihost. La secuencia de comandos de ejemplo usa v6e-16.

Crea variables de entorno para los parámetros de creación 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

Descripciones de las variables de entorno

Variable	Descripción
`PROJECT_ID`	El ID de tu proyecto Google Cloud . Usa un proyecto que ya tengas o crea uno.
`TPU_NAME`	El nombre de la TPU.
`ZONE`	La zona en la que se creará la VM de TPU. Para obtener más información sobre las zonas admitidas, consulta Regiones y zonas de TPU.
`ACCELERATOR_TYPE`	El tipo de acelerador especifica la versión y el tamaño de la TPU de Cloud que quieres crear. Para obtener más información sobre los tipos de aceleradores compatibles con cada versión de TPU, consulta Versiones de TPU.
`RUNTIME_VERSION`	La versión de software de la TPU de Cloud.

Usa el siguiente comando para crear una VM de TPU v6e con 16 núcleos:

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

Instala JAX y Ray en todos los trabajadores de 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"

Guarda el siguiente código en un archivo. Por ejemplo, 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 estás acostumbrado a ejecutar Ray con GPUs, hay algunas diferencias clave al usar TPUs:
- Al igual que las cargas de trabajo de PyTorch en GPUs:
  - Las cargas de trabajo de JAX en TPUs se ejecutan en un modo de varios controladores, un solo programa y varios datos (SPMD).
  - El framework de aprendizaje automático gestiona las colectividades entre dispositivos.
- A diferencia de las cargas de trabajo de PyTorch en GPUs, JAX tiene una vista global de los dispositivos disponibles en el clúster.

Copia la secuencia de comandos en todos los trabajadores de TPU.

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

Ejecuta la secuencia de comandos.

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

Ejecutar una carga de trabajo de JAX de Multislice

Multislice te permite ejecutar cargas de trabajo que abarcan varias porciones de TPU en un único pod de TPU o en varios pods a través de la red del centro de datos.

Puedes usar el paquete ray-tpu para simplificar las interacciones de Ray con las porciones de TPU.

Instala ray-tpu con pip.

pip install ray-tpu

Para obtener más información sobre el uso del paquete ray-tpu, consulta la sección Primeros pasos del repositorio de GitHub. Para ver un ejemplo de uso de Multislice, consulta Ejecutar en Multislice.

Orquestar cargas de trabajo con Ray y MaxText

Para obtener más información sobre cómo usar Ray con MaxText, consulta Ejecutar un trabajo de entrenamiento con MaxText.

Recursos de TPU y Ray

Ray trata las TPUs de forma diferente a las GPUs para adaptarse a la diferencia de uso. En el siguiente ejemplo, hay nueve nodos de Ray en total:

El nodo principal de Ray se ejecuta en una n1-standard-16 VM.
Los nodos de trabajador de Ray se ejecutan en dos TPUs v6e-16. Cada TPU consta de cuatro trabajadores.

$ 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)

Descripciones de los campos de uso de recursos:

CPU: número total de CPUs disponibles en el clúster.
TPU: número de chips de TPU del clúster.
TPU-v6e-16-head: identificador especial del recurso que corresponde al trabajador 0 de un segmento de TPU. Esto es importante para acceder a las porciones de TPU individuales.
memory: memoria de montículo de trabajador usada por tu aplicación.
object_store_memory: memoria usada cuando tu aplicación crea objetos en el almacén de objetos mediante ray.put y cuando devuelve valores de funciones remotas.
tpu-group-0 y tpu-group-1: identificadores únicos de los slices de TPU individuales. Esto es importante para ejecutar trabajos en segmentos. Estos campos tienen el valor 4 porque hay 4 hosts por segmento de TPU en una v6e-16.