Portar cargas de trabalho do JAX para o Pathways

Este documento é destinado a engenheiros de machine learning que estão portando cargas de trabalho do JAX para o Pathways no Google Kubernetes Engine (GKE). Ela explica como a execução de controlador único afeta a indexação de dispositivos, o dimensionamento do host da CPU, a integração do pathwaysutils, a criação de checkpoints, o carregamento de dados, o armazenamento em cache de compilação, a criação de perfis e as flags do XLA.

Antes de começar

Siga os seguintes pré-requisitos:

Índice de processos

O JAX com Pathways trata todos os dispositivos no cluster do Pathways como locais, o que simplifica o gerenciamento de dispositivos e permite que o JAX use todos os recursos disponíveis. Na prática, isso significa:

  • jax.process_index() sempre retorna 0 para todos os dispositivos.
  • jax.devices() e jax.local_devices() retornam todos os dispositivos do Cloud TPU em todo o job.

Tipo de hardware e colocation

Para ter o melhor desempenho, coloque todos os componentes do Pathways e o job do JAX na mesma zona doGoogle Cloud . Execute os componentes do nó principal da CPU, como o servidor proxy IFRT, o gerenciador de recursos do Pathways e (para cargas de trabalho em lote) o processo do controlador JAX, em uma VM de CPU dedicada de alta capacidade para lidar com a sobrecarga de compilação e coordenação. Use pelo menos um tipo de máquina n2-standard-64, que fornece 64 vCPUs e 256 GB de memória.

O pacote pathwaysutils

Pathways-utils é um pacote Python de código aberto que integra cargas de trabalho do JAX ao Pathways no Cloud. Ele oferece os seguintes recursos para ajudar você a se concentrar nos fluxos de trabalho de machine learning com o mínimo de alterações de configuração:

  • Proxy de back-end do JAX: ativa o back-end do Pathways quando você define a variável de ambiente JAX_PLATFORMS=proxy.
  • Utilitários de criação de perfil integrados: permitem criar perfis do código JAX e dos componentes do Pathways usando APIs de criação de perfil JAX padrão, como jax.profiler.start_trace e jax.profiler.start_server.
  • Checkpoints distribuídos com o Orbax: registra gerenciadores de checkpoint personalizados do Orbax ao importar pathwaysutils, permitindo salvar e restaurar checkpoints distribuídos sem mudar o código do Orbax.
  • Primitivas de treinamento elástico: fornecem elementos básicos para o treinamento elástico, para que seus jobs de treinamento possam se adaptar dinamicamente às mudanças nas frações disponíveis do Cloud TPU.

Como estabelecer pontos de verificação

O Orbax é testado com o Pathways para checkpoint e restauração distribuídos com o Cloud Storage. Quando você define a variável de ambiente ENABLE_PATHWAYS_PERSISTENCE=1 e chama import pathwaysutils; pathwaysutils.initialize() no script de treinamento, o Pathways registra um ArrayHandler personalizado. Ele executa operações de checkpoint pelo proxy do Interim Framework Runtime (IFRT), permitindo que os workers do Pathways em aceleradores salvem e restaurem dados diretamente.

Python colocalizado

O Python colocalizado é uma API JAX de código aberto que permite executar código Python especificado pelo usuário diretamente em CPUs de host conectadas a aceleradores. No GKE, o Pathways executa o Python colocalizado em VMs de worker do Cloud TPU para evitar a transferência de dados do host pelo controlador para carregamento de dados e checkpointing.

Para criar uma imagem de contêiner secundário personalizada e configurar o JobSet do Pathways com memória de host compartilhada de cópia zero, consulte Executar o Python colocalizado com o Pathways.

Carregamento de dados

Durante o treinamento, a carga de trabalho carrega repetidamente lotes de um conjunto de dados para alimentar o modelo. O uso de um carregador de dados assíncrono e eficiente que fragmenta cada lote entre hosts evita que os aceleradores fiquem sem trabalho. No treinamento padrão do Pathways, o carregador de dados é executado em uma VM de CPU (em vez de VMs de worker do Cloud TPU, como em configurações de vários controladores) e envia dados para VMs do Cloud TPU. A leitura na rede adiciona latência, que o Pathways mitiga parcialmente lendo vários lotes no host da CPU e enviando os dados de forma assíncrona para as Cloud TPUs. Essa abordagem é suficiente em pequena e média escala.

Quando você executa um carregador de dados multiprocesso (como o Grain) no contêiner de carga de trabalho principal no GKE, o contêiner compartilha o nó principal com os contêineres pathways-proxy e pathways-rm. Por causa desse host compartilhado, configure o seguinte:

  • Defina uma contagem explícita de workers: dentro de um contêiner, os.cpu_count() informa o total de vCPUs da VM host, em vez do limite de CPU do contêiner. Transmita uma contagem explícita de workers (não mais do que o limite de CPU do contêiner) em vez de derivá-la de os.cpu_count().
  • Monte um volume /dev/shm com suporte de memória: os carregadores de dados multiprocesso usam a memória compartilhada POSIX (/dev/shm) para comunicação entre processos. Ative um volume emptyDir (medium: Memory) com suporte de memória em /dev/shm para que os lotes pré-buscados não excedam o limite de memória compartilhada do contêiner padrão.

Para otimizar o desempenho em escala, coloque o pipeline de dados de entrada no mesmo local usando o Python no mesmo local para que ele seja executado diretamente nos hosts de worker da TPU do Cloud TPU. Isso elimina o gargalo da CPU e usa as interconexões do Cloud TPU para uma transferência de dados rápida.

Para um exemplo de referência de migração de um pipeline de entrada baseado em TFDS, consulte a implementação de RemoteIterator em multihost_dataloading.py. Essa implementação funciona tanto no JAX com vários controladores quanto no Pathways usando a API JAX do Python colocalizada.

Controle de versões do JAX

As versões do Pathways são fortemente acopladas às versões do JAX para compatibilidade e estabilidade. Verifique se as imagens de contêiner do Pathways e a versão do JAX estão alinhadas. Cada versão do Pathways especifica a versão compatível do JAX por meio de uma tag de imagem no formato jax-<version>.

Cache de compilação

O cache de compilação persistente do Pathways armazena executáveis XLA compilados em um local persistente, como o Cloud Storage, para evitar compilações redundantes. Esse recurso é ativado por padrão quando você transmite --gcs_scratch_location para os contêineres pathways-proxy, pathways-rm e pathways-worker (ou worker). Para manter os custos de armazenamento baixos, o cache anexa uma política de ciclo de vida de objeto ao bucket do Cloud Storage. Como o Cloud Storage limita os buckets a 50 políticas de ciclo de vida, use um local comum do Cloud Storage em todas as cargas de trabalho.

Se você omitir a flag --gcs_scratch_location ou deixá-la vazia, o Pathways vai usar um cache de compilação na memória. Esse cache não mantém os executáveis XLA compilados nas implantações do Pathways.

Esse cache é semelhante ao cache de compilação do JAX, que o pathwaysutils.initialize() desativa para cargas de trabalho do Pathways.

O cache de compilação requer as seguintes permissões do Cloud Storage:

  • storage.buckets.get: recupera metadados do bucket.
  • storage.buckets.update: permite que o Pathways configure políticas de ciclo de vida de objetos para aplicar o TTL para remoção de cache.
  • storage.objects.list: lista os objetos de cache no bucket.
  • storage.objects.create: grava novos executáveis compilados no cache.
  • storage.objects.get: lê executáveis armazenados em cache no bucket.

Criação de perfil

É possível usar o criador de perfil do JAX para gerar traces de um programa JAX de duas maneiras:

  • Programática: capture perfis diretamente do código JAX.
  • Manual: capture perfis on demand depois de iniciar o servidor do criador de perfil no código JAX.

Em ambos os casos, o Pathways grava os perfis em um bucket do Cloud Storage e cria vários arquivos de rastreamento, possivelmente em diretórios de carimbo de data/hora diferentes, por exemplo:

  • Processo principal do Python que invocou o trace (normalmente, a VM do notebook): JAX_CLIENT_VM_NAME.xplane.pb
  • Proxy IFRT do Pathways: client.PATHWAYS_HEAD_NODE_NAME.xplane.pb
  • Gerenciador de recursos do Pathways: server.*PATHWAYS_HEAD_NODE_NAME.xplane.pb
  • Workers do Pathways: server.*TPU_NODE_NAME.xplane.pb

É possível analisar esses arquivos de trace com o TensorBoard executando os seguintes comandos. Para mais informações sobre o TensorBoard e as ferramentas de criação de perfil, consulte Otimizar o desempenho do TensorFlow usando o Profiler.

# Verify that trace files are present
gcloud storage ls -l -r gs://BUCKET/PREFIX

# View on TensorBoard
tensorboard --load_fast=false --logdir=gs://BUCKET/PREFIX

Substitua:

  • BUCKET: o bucket do Cloud Storage que armazena os arquivos de rastreamento.
  • PREFIX: o caminho no bucket do Cloud Storage que armazena os arquivos de rastreamento.

Captura de perfil programática

Capturar um perfil de dentro do código. O Pathways salva os perfis em gs://BUCKET/PREFIX em um diretório de carimbo de data/hora:

import jax
import pathwaysutils

pathwaysutils.initialize()

jax.profiler.start_trace("gs://BUCKET/PREFIX")

# Run the operations to be profiled
key = jax.random.key(0)
x = jax.random.normal(key, (5000, 5000))
y = x @ x
y.block_until_ready()

jax.profiler.stop_trace()

Captura manual de perfil

Para capturar informações de perfil manualmente, inicie o servidor do criador de perfil no código Python:

import jax
import pathwaysutils

pathwaysutils.initialize()

jax.profiler.start_server(JAX_PROFILER_PORT)

# Your JAX code
jax.profiler.stop_server()

Substitua JAX_PROFILER_PORT pelo número da porta do servidor do criador de perfil do JAX.

Enquanto o servidor do criador de perfil estiver em execução, capture um perfil e exporte os dados para o local de destino do Cloud Storage. Execute o seguinte comando no contêiner da carga de trabalho ou depois de encaminhar JAX_PROFILER_PORT do pod pathways-head:

export DURATION_IN_SECS=6
export OUTPUT_DIR="gs://BUCKET/PREFIX/"

curl -X POST http://localhost:JAX_PROFILER_PORT/profiling \
     -H "Content-Type: application/json" \
     -d "{\"duration_ms\": $((DURATION_IN_SECS * 1000)), \"repository_path\": \"${OUTPUT_DIR}\"}"

É possível encontrar informações de tempo para métodos de cliente proxy do IFRT, como Compile e Execute, no trace do programa. Esses eventos, que detalham as interações com o servidor gRPC do proxy IFRT durante a compilação e a execução, aparecem na linha de execução chamada GrpcClientSessionUserFuturesWorkQueue. Examinar essa linha de execução no rastro fornece insights sobre o desempenho dessas operações.

Sinalizações de XLA

Ao usar o Pathways, defina as flags do XLA no contêiner pathways-proxy.

Ao usar o Cluster Toolkit (o comando gcluster job submit), defina as flags do XLA usando --pathways-proxy-args:

--pathways-proxy-args="--xla_flag_1=value1 --xla_flag_2=value2"

Despejo de HLO

Para inspecionar as entradas do High-Level Optimizer (HLO) transmitidas ao compilador XLA, configure o Pathways para despejar o HLO em um local do Cloud Storage usando --pathways-proxy-args:

--pathways-proxy-args="--xla_dump_to=gs://BUCKET_NAME/HLO_PREFIX/"

Substitua:

  • BUCKET_NAME: o bucket do Cloud Storage para o despejo de HLO.
  • HLO_PREFIX: o prefixo do caminho no bucket.

A seguir