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:
- Crie um cluster do GKE com o Pathways.
- Configure o Cluster Toolkit.
- Instale as ferramentas do Kubernetes.
- Instale a CLI do Google Cloud.
- Ative a API Kubernetes Engine.
- Crie um bucket do Cloud Storage para checkpoints, artefatos de cache de compilação e traces do criador de perfil.
- Instale
jaxepathwaysutilsno ambiente de carga de trabalho.
Í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 retorna0para todos os dispositivos.jax.devices()ejax.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_traceejax.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 deos.cpu_count(). - Monte um volume
/dev/shmcom suporte de memória: os carregadores de dados multiprocesso usam a memória compartilhada POSIX (/dev/shm) para comunicação entre processos. Ative um volumeemptyDir(medium: Memory) com suporte de memória em/dev/shmpara 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.