Solução de problemas

Neste guia, você verá soluções de problemas para os usuários que querem executar os próprios modelos do TensorFlow na Cloud TPU. Para ver um guia mais geral sobre como dar os primeiros passos com a Cloud TPU, consulte o guia de início rápido ou o tutorial do MNIST.

Visão geral

A estratégia recomendada para executar os modelos do TensorFlow na Cloud TPU é usar a API TPUEstimator (em inglês). Se você já usa a API Estimator (em inglês) do TensorFlow, geralmente é necessário alterar apenas algumas linhas de código para trocar para a TPUEstimator. A maneira recomendada de carregar dados na TPUEstimator é com a API tf.data (em inglês). Veja em Como usar a API TPUEstimator com a Cloud TPU o exemplo real do MNIST de como implementar TPUEstimator e tf.data. Consulte também Estimator do MNIST para TPUEstimator (em inglês).

Depois de converter o modelo para TPUEstimator, verifique se ele funciona com a sinalização use_tpu=False. Se você definir a sinalização como false, o TensorFlow retornará à API Estimator e não usará um código relativo à TPU. Quaisquer problemas encontrados ao executar o modelo com use_tpu=False não são relativos à TPU e estão fora do escopo deste guia. Nesse caso, consulte o Guia para programadores do TensorFlow (em inglês).

O ideal é que, quando for possível executar um modelo usando TPUEstimator e use_tpu=False, a execução dele na TPU seja apenas uma questão de definir use_tpu=True e apontar master para um URL de servidor de TPU. Isso geralmente é feito com um resolvedor de cluster (em inglês). No entanto, como os modelos do TensorFlow podem ser muito complexos e a TPU usa um mecanismo de execução próprio, é possível que ocorram problemas específicos da TPU. Esses problemas estão incluídos nas cinco amplas categorias a seguir:

  1. Não consigo conectar o script de treinamento ao servidor da TPU de nenhuma maneira.

  2. Ocorre um erro na TPU ao tentar executar o modelo.

  3. O modelo não cabe na memória da TPU.

  4. O modelo é executado na TPU, mas a velocidade de treinamento não é tão rápida quanto esperado.

  5. O modelo é executado na TPU, mas a acurácia do modelo treinado pela TPU é pior do que um valor de referência treinado pela CPU/GPU.

Além disso, você encontra neste guia perguntas frequentes sobre a funcionalidade geral disponível nas TPUs.

Para encontrar mais ajuda especializada sobre a portabilidade de tipos específicos de redes neurais para a TPU, consulte os tutoriais da Cloud TPU.

Problema ao se conectar ao servidor da TPU

Ao executar um modelo na TPU, é necessário passar um URL remoto do servidor da TPU para o parâmetro master em RunConfig. Em segundo plano, o TensorFlow cria um tf.Session remoto com esse servidor. Essa seção fornece soluções de problemas para quando o TensorFlow trava ou exibe um erro ao se conectar ao servidor da TPU. A etapa de compilação do grafo da TPU pode levar muito tempo nos modelos grandes. Portanto, execute o script por pelo menos 5 minutos antes de confirmar que ele travou.

A primeira etapa é verificar se o problema está no próprio servidor ou no pipeline de treinamento do TensorFlow. Para isso, execute o tutorial do MNIST usando o URL de servidor da TPU e verifique se funciona corretamente. Caso você ainda encontre problemas de conexão no tutorial do MNIST, isso confirma que o problema é no servidor da TPU. Nesse caso, siga estas etapas:

  1. Execute o comando a seguir para listar as TPUs disponíveis:

    (vm)$ gcloud compute tpus list
    

    Talvez seja necessário também definir zone e project, conforme mostrado no tutorial do MNIST. Isso exibe um resultado como este:

    NAME       ZONE           ACCELERATOR_TYPE  NETWORK_ENDPOINT   NETWORK  RANGE          STATUS
    demo-tpu   us-central1-b  v2-8              10.240.1.2:8470    default  10.240.1.0  READY

  2. Verifique se o valor passado para --tpu (demo-tpu no exemplo acima) está correto e se a TPU consta como READY. Também confirme se zone e project foram configurados conforme abaixo:

    (vm)$ gcloud config set project your-project-name
    
    (vm)$ gcloud config set compute/zone us-central1-b
    
  3. Se a TPU não constar como READY ou se você ainda estiver com problemas de conexão, reinicie manualmente o servidor com gcloud compute tpus stop $TPU_SERVER_NAME && gcloud compute tpus start $TPU_SERVER_NAME. No exemplo acima, $TPU_NAME é demo-tpu. Isso pode levar algum tempo.

  4. Execute novamente o comando ... tpus list acima e espere a TPU entrar no estado READY. Isso pode levar algum tempo.

  5. Tente executar o tutorial do MNIST novamente.

  6. Se você ainda estiver com problemas para executar o tutorial MNIST, peça ajuda usando um dos mecanismos descritos em Como receber suporte.

Se o exemplo do MNIST for executado corretamente, mas o modelo continuar travando, é provável que o problema seja com o pipeline de treinamento. Primeiro, verifique se o modelo usa a API TPUEstimator (em inglês). Além de lidar com o pipeline de processamento complexo, ela possibilita a troca simples entre a execução de TPU e não TPU com a sinalização use_tpu. Consulte os tutoriais de TPU para ver vários exemplos de como usar a TPUEstimator. Depois que começar a usar a API TPUEstimator no modelo, verifique se ele é executado corretamente quando use_tpu=False está definido. Se o modelo não for executado corretamente quando use_tpu=False estiver definido, o problema não tem relação com a TPU.

Como depurar erros comuns

Não é possível usar o sistema de arquivos local

Mensagem de erro

InvalidArgumentError: Unimplemented: File system scheme '[local]' not implemented

Detalhes

Todos os arquivos de entrada e o diretório do modelo precisam usar um caminho do intervalo do Cloud Storage (gs://bucket-name/...). Esse intervalo precisa ser acessível do servidor da TPU. Todo o processamento de dados e a criação de checkpoints do modelo são executados no servidor da TPU, e não na máquina local. Para mais informações sobre como configurar corretamente o Cloud Storage para usá-lo com a TPU, consulte o guia Como conectar-se a intervalos do Cloud Storage.

tf.data.Dataset.cache() não pode realizar armazenamento em cache no sistema de arquivos local

Mensagem de erro

tensorflow.python.framework.errors_impl.UnimplementedError: File system scheme '[local]' not implemented (file: '[filename].lockfile')

Detalhes

Um tf.data.Dataset pode ser armazenado em cache. A chamada .cache() tem duas implementações:

  1. Na memória, se nenhum argumento for passado

  2. Em um sistema de arquivos, se um caminho de arquivo for passado como um argumento

Na Cloud TPU, (1) funciona (desde que caiba na memória disponível), mas (2) não funciona no salvamento no sistema de arquivos local, resultando no erro acima.

Os snippets de código a seguir ilustram as duas situações:

(1)
 import tensorflow as tf

def main():
  print('Hello world!')
  ds = tf.data.Dataset.range(10)
  ds = ds.cache()

runs to completion.

(2)
 import tensorflow as tf

def main():
  print('Hello world!')
  ds = tf.data.Dataset.range(10)
  ds = ds.cache('/tmp/foo')

generates the error.

O guia da API (em inglês) tem informações mais detalhadas sobre tf.data.Dataset.cache().

Tipo de dados incompatível

Mensagem de erro

TypeError: DataType is not a supported TPU infeed type.

Detalhes

No momento, somente os tipos de dados tf.float32, tf.int32, tf.bfloat16 e tf.bool são compatíveis com a TPU. Outros tipos de dados comuns, como tf.uint8, tf.string e tf.int64, precisam ser convertidos para um dos tipos de dados compatíveis durante o pré-processamento (isto é, em input_fn de TPUEstimator). Consulte o tutorial do MNIST para ver outra amostra. Como exemplo, este snippet de código do MNIST converte um tensor image armazenado como uma sequência de bytes tf.uint8 para um tensor tf.float32:

image = tf.decode_raw(image, tf.uint8)
image = tf.cast(image, tf.float32)
image = tf.reshape(image, [784])

Este snippet converte um tensor label armazenado como tf.int64 para um tensor tf.int32:

label = tf.cast(label, tf.int32)

Formas dinâmicas incompatíveis

Mensagem de erro

ValueError: shape [Shape] must have a fixed size for dimension d that is known at graph construction time.

Detalhes

Para executar um modelo na TPU, o TensorFlow o compila usando o framework XLA (em inglês). Essa etapa de compilação aumenta bastante a velocidade de treinamento e o uso de memória. No entanto, as formas ou tamanhos de dimensão de todos os tensores no grafo precisam ser estáticos. Isso significa que seus valores precisam ser conhecidos no momento da compilação do grafo. Se não for possível determinar formas nesse momento, a compilação da TPU falhará com um erro como o acima.

Uma operação comum que retorna uma forma dinâmica é dataset.batch(batch_size), já que o número de amostras restantes em um fluxo pode ser menor que o tamanho do lote. Portanto, ao realizar treinamentos na TPU, use tf.contrib.data.batch_and_drop_remainder(batch_size). Isso possivelmente elimina as últimas amostras de um arquivo para garantir que cada lote tenha a forma estática de batch_size. Por exemplo:

dataset = ...
dataset = dataset.apply(tf.contrib.data.batch_and_drop_remainder(batch_size))

Operação do TensorFlow indisponível

Mensagem de erro

NotFoundError: No registered 'OpName' OpKernel for XLA_TPU_JIT devices compatible with node

Detalhes

O modelo usa uma operação do TensorFlow que não está atualmente disponível na TPU.

Para ver uma lista de operações disponíveis na TPU, planos para compatibilidade futura e sugestões de soluções alternativas, consulte o guia sobre operações disponíveis do TensorFlow.

Mensagem de erro de falta de memória

Mensagem de erro

ResourceExhaustedError: Ran out of memory in memory space hbm; used: YYY; limit: 7.48G.

Detalhes

Cada Cloud TPU é formada por oito núcleos, todos com 8 GB de RAM (ou HBM, memória de alta largura de banda, na sigla em inglês). Essa memória é usada para armazenar os tensores de peso (variáveis), bem como os de resultados intermediários necessários para o cálculo do gradiente. Se o modelo for muito grande para caber na RAM da TPU, a inicialização falhará, e a mensagem de erro acima será exibida. Consulte a seção sobre como reduzir o uso de memória para encontrar mais ajuda.

CrossShardOptimizer não usado

Mensagem de erro

ValueError: CrossShardOptimizer must be used for model training on TPUs.

Detalhes

Na definição de um modelo usando a API do TensorFlow para Python, a grande maioria do código escrito pelo usuário não precisa ser especializada para a TPU. A exceção mais significativa é o otimizador, que precisa ser incorporado em tf.contrib.tpu.CrossShardOptimizer(), conforme mostrado abaixo.

optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
if FLAGS.use_tpu:
  optimizer = tf.contrib.tpu.CrossShardOptimizer(optimizer)
train_op=optimizer.minimize(loss, tf.train.get_global_step())

Cada Cloud TPU é formada por 8 núcleos, que são unidades de processamento independentes. Em cada etapa de treinamento ou atualização de peso, todos esses núcleos calculam os valores de saída e fazem a computação do gradiente em um pequeno lote independente de dados. Em seguida, eles trocam gradientes entre si. Na maioria dos casos, isso é matematicamente equivalente a calcular os gradientes em um lote grande, mesmo havendo algumas ressalvas explicadas em Noções básicas sobre a fragmentação de dados.

CrossShardOptimizer é a operação responsável por essa troca de gradientes. Por padrão, o CrossShardOptimizer calcula os gradientes da perda média nos núcleos. No entanto, é possível configurá-lo para calcular a perda somada passando reduction=losses.Reduction.SUM.

Não é possível se conectar ao servidor da TPU

Mensagem de erro

An error was raised while a session was being created. This may be due to a preemption of a connected worker or parameter server. A new session is created.

Detalhes

Esse erro é exibido quando o TensorFlow não consegue se conectar ao URL do servidor da TPU, que é transmitido para o master. Para encontrar ajuda, consulte a seção sobre problemas ao se conectar ao servidor da TPU.

Erros no meio do treinamento

Todos os erros relacionados à falha na execução do modelo na TPU foram projetados para serem descobertos durante a inicialização. Portanto, é raro que um modelo falhe no meio do treinamento. Se isso acontecer, a causa mais provável é um problema na função de pré-processamento de dados. Por exemplo, ao usar a API Dataset, você normalmente precisa chamar dataset = dataset.repeat(). Caso contrário, o treinamento falhará após a primeira transmissão pelos dados. As operações de execução dinâmicas, como tf.while_loop(), também só falham de modo dependente dos dados de entrada. Além disso, há a rara possibilidade de hardware falso ou falhas de rede.

Problemas que interrompem a execução

Quando há erro no TensorFlow durante a execução da TPU, o script às vezes trava em vez de sair para o shell. Se isso acontecer, pressione CTRL+\ no teclado para acionar SIGQUIT e encerrar o Python imediatamente.

Da mesma forma, pressionar CTRL+C durante a execução da TPU não encerra o TensorFlow imediatamente. Em vez disso, ele aguarda o fim do ciclo de iteração atual para encerrar corretamente. Pressione CTRL+\ para encerrar o Python imediatamente.

Se ocorrer algum novo erro, como DeadlineExceededError, para se reconectar ao servidor da TPU após encerrar dessa maneira, redefina manualmente o servidor da TPU usando o comando gcloud compute tpus stop $TPU_SERVER_NAME && gcloud compute tpus start $TPU_SERVER_NAME, em que $TPU_SERVER_NAME é retirado da primeira coluna do comando gcloud compute tpus list.

Como reduzir o uso da memória

Se ocorrer um erro de falta de memória ao executar o modelo na TPU, você precisará reduzir o uso da memória. Nesta seção, descrevemos várias causas principais dos problemas de memória e fornecemos diretrizes para solucioná-los.

Grande número de pesos de modelo

Possível causa do problema de memória

Cada peso de modelo float32 requer 4 bytes. Eles são replicados em cada núcleo da TPU. Portanto, um modelo com centenas de milhões de pesos provavelmente será grande demais para caber na TPU.

Como reduzir o uso de memória

  1. Alguns otimizadores exigem mais memória por peso para armazenar estatísticas de atualização. Especialmente AdamOptimizer e AdadeltaOptimizer requerem 8 bytes extras por peso. Já AdagradOptimizer e MomentumOptimizer exigem 4. O padrão GradientDescentOptimizer não requer armazenamento extra. No entanto, ele pode não ter o mesmo desempenho de outros otimizadores em termos de acurácia final do modelo. O experimental AdafactorOptimizer (em inglês) exige quase nenhuma memória extra. Ele tem o mesmo desempenho do otimizador Adam de valor de referência ao treinar modelos Transformer.
  2. Se a maioria dos pesos estiver relacionada a embeddings de palavras, use técnicas como o WordPiece (em inglês), que reduzem bastante o tamanho do vocabulário e aumentam a acurácia em várias tarefas.
  3. Uma próxima versão do TensorFlow oferecerá compatibilidade experimental com gradientes e pesos de ponto flutuante de 16 bits, o que reduzirá pela metade os requisitos de memória.

Preenchimento excessivo do tensor

Possível causa do problema de memória

Os tensores na memória da TPU são preenchidos. Isso significa que a TPU arredonda os tamanhos dos tensores armazenados na memória para executar cálculos com mais eficiência. O preenchimento acontece de modo evidente no nível do hardware e não afeta os resultados. No entanto, em alguns casos, o preenchimento aumenta bastante o uso de memória e o tempo de execução.

Como reduzir o uso de memória

O software da TPU exibe os tensores na memória para aumentar a eficiência computacional e minimizar o preenchimento. Esse processo de exibição da memória é complexo. No entanto, para conseguir os melhores resultados, o modelo precisa cumprir a regra geral a seguir. Para reduzir a sobrecarga de memória e aumentar a eficiência computacional, é necessário que:

  • o tamanho total do lote seja um múltiplo de 64 (8 por núcleo de TPU) e as dimensões do recurso sejam um múltiplo de 128;

    ou

  • o tamanho total do lote seja um múltiplo de 1024 (128 por núcleo de TPU) e as dimensões do recurso sejam um múltiplo de 8.

Usando um tamanho de lote de 1024 e dimensões de recurso que sejam um múltiplo de 128, você garante uma melhor eficiência, mesmo que isso não seja possível em todos os modelos. Para maior clareza, a "dimensão de recurso" se refere ao tamanho oculto de uma camada totalmente conectada ou ao número de canais de saída em uma convolução. Nem todas as camadas seguem essa regra, especialmente a primeira e a última da rede. Isso não é um problema, e é esperado que a maioria dos modelos exija uma certa quantidade de preenchimento.

Tamanho de lote muito grande

Possível causa do problema de memória

Ao treinar uma rede neural em uma CPU, GPU ou TPU, o uso da memória é proveniente de um destes:

  1. Armazenamento dos pesos, gradientes de peso e estatísticas específicas do otimizador, como Momentum. O uso da memória é diretamente proporcional ao número de pesos no modelo, mas não ao tamanho do lote;
  2. armazenamento de ativações intermediárias da transmissão para frente necessário para calcular a transmissão para trás. O uso da memória é diretamente proporcional aos tamanhos do lote e da camada e ao número de camadas.

Portanto, a memória exigida por um modelo é muito dependente do tamanho do lote.

Como reduzir o uso de memória

Reduza lentamente o tamanho do lote até que ele caiba na memória, verificando se ele é múltiplo de 64. O tamanho do lote por núcleo precisa ser múltiplo de 8. Lembre-se de que tamanhos de lote maiores são mais eficientes na TPU. O tamanho total de 1024 (128 por núcleo) costuma ser um bom ponto de partida.

Modelo muito grande

Possível causa do problema de memória

A memória exigida por um modelo é muito dependente do número de operadores no gráfico, ou seja, das camadas na rede. Esse requisito é separado do número de pesos. Por exemplo, calcular o gradiente de um operador como tf.nn.conv2d() aumenta o uso da memória, além de qualquer memória usada para armazenar pesos.

O mecanismo da TPU recalcula estrategicamente determinados operadores para ajustar o modelo na memória. Isso é chamado de rematerialização e é similar à criação de checkpoints de gradiente (ambos em inglês). No entanto, o mecanismo nem sempre é capaz de fazer isso.

Como reduzir o uso de memória

Se não for possível executar o modelo na TPU mesmo com um tamanho de lote pequeno (por exemplo, 64), reduza o número de camadas ou os tamanhos delas. Uma próxima versão do TensorFlow será compatível com o "paralelismo de modelos" na TPU. Isso possibilita a execução de modelos muito maiores na Cloud TPU com a execução de diferentes partes do modelo em diferentes núcleos da TPU.

Como melhorar a velocidade do treinamento

Nesta seção, descrevemos várias maneiras possíveis de melhorar a velocidade do treinamento caso você consiga executar o modelo na TPU, mas a velocidade é mais lenta que o esperado.

Muito poucas iterações por ciclo

Descrição do problema de desempenho

O parâmetro iterations_per_loop para TPUConfig controla quantos lotes de dados são enviados à TPU em um único "ciclo de treinamento". Cada um deles requer bastante comunicação entre a máquina local e o servidor da TPU. Portanto, se iterations_per_loop for muito pequeno, o treinamento poderá ser muito lento.

Como saber se o modelo foi afetado

Se a mensagem de registro Enqueue next (X) batch(es) of data to infeed for exibida com muita frequência (por exemplo, a cada 3 segundos), é provável que o treinamento tenha uma grande sobrecarga proveniente do ciclo.

Como mitigar

Defina iterations_per_loop como um valor maior. No tutorial do MNIST, isso é controlado pela sinalização --iterations. Contanto que a mensagem Enqueue next (X) batch(es) of data to infeed não seja exibida mais do que algumas vezes por minuto, o valor atual será suficiente. Observe que iterations_per_loop pode ser definido como um valor muito grande. A única desvantagem é que, nesse caso, as mensagens de registro e a criação de checkpoints só podem ocorrer no final de um loop.

Gargalo de processamento de entrada

Descrição do problema de desempenho

Enquanto a TPU realiza o treinamento em um determinado bloco de dados, a função de processamento de entrada prepara o próximo bloco na CPU. Assim, se a função de entrada leva menos tempo que a de modelo, o custo do processamento de entrada é efetivamente zero. No entanto, uma função de entrada que leva mais tempo que a função de modelo cria um gargalo.

Como saber se o modelo foi afetado

Siga as instruções em Ferramentas da Cloud TPU: analisador do pipeline de entrada para ver a respectiva análise no TensorBoard:

imagem

A página de análise do pipeline de entrada exibe um resumo claro que mostra se o modelo tem gargalo do processamento de entrada. Ela também exibe o tempo de execução por operação para identificar as operações problemáticas.

Como mitigar

Há várias mitigações possíveis no carregamento de dados com a API Dataset:

  1. Armazenar os dados como uma coleção de estruturas tf.train.Example em arquivos TFRecord e carregá-los com TFRecordDataset. Consulte o tutorial da API Dataset (em inglês) ou do ResNet para ver exemplos.
  2. Usar dataset.cache() e/ou dataset.prefetch() para armazenar em buffer os dados de entrada. Isso evita que lentidões esporádicas no acesso aos arquivos criem um gargalo.
  3. Especificar o parâmetro num_parallel_calls da função dataset.map() para ativar operações map() com várias linhas de execução.
  4. O pré-processamento de dados off-line é caro, mas pode ser pago uma única vez para que não seja necessário gerá-lo em todos os períodos de cada treinamento.

Todo o processamento de entrada é executado em CPUs localizadas no servidor da TPU, e não na máquina local. Portanto, a velocidade da máquina local não é um fator.

Muitas operações de multiplicação não matricial

Descrição do problema de desempenho

A Cloud TPU realiza convoluções e multiplicações de matrizes a velocidades incrivelmente altas. A maioria das outras operações do TensorFlow conta com implementações eficientes na TPU. No entanto, essa não é a principal qualidade da TPU em relação a outros hardwares. Portanto, é necessário que as convoluções ou multiplicações de matrizes sejam predominantes no modelo para aproveitar ao máximo a TPU.

Como saber se o modelo foi afetado

No guia Ferramentas da Cloud TPU: perfil das operações, você verá como gerar um perfil de desempenho para o modelo de acordo com o tipo de operação. Em geral, as convoluções e multiplicações de matrizes são predominantes na grande maioria das arquiteturas modernas de rede neural.

Como mitigar

Se a falta de multiplicações de matrizes no modelo for motivada principalmente por problemas na velocidade do treinamento em outro hardware, recomendamos que você faça novamente a comparação desses modelos na TPU para melhorar a velocidade. Se essa falta for uma propriedade fundamental do modelo, talvez a TPU não seja a melhor opção de hardware.

Preenchimento excessivo do tensor

Descrição do problema de desempenho

A TPU preenche os tensores na memória para poder usar as unidades computacionais com eficiência. O preenchimento pode aumentar o uso da memória e da respectiva largura de banda. Consulte a seção sobre preenchimento de tensor para entender e solucionar os problemas relacionados.

Tamanho do lote muito pequeno

Descrição do problema de desempenho

Como regra geral, o uso de lotes maiores aumenta a velocidade de treinamento na TPU em termos de amostras/segundo.

Como saber se o modelo foi afetado

O tamanho do lote de qualquer modelo precisa sempre ser pelo menos 64 (8 por núcleo de TPU), já que a TPU preenche os tensores nesse tamanho. O tamanho ideal ao treinar na TPU é de 1024 (128 por núcleo de TPU). Isso elimina as ineficiências relacionadas à transferência de memória e preenchimento.

Como mitigar

Recomendamos que você use o maior tamanho de lote que se encaixe na memória e seja múltiplo de 64. Para isso, o jeito mais fácil é começar com 1024. Se ocorrer um erro de falta de memória, reduza o tamanho do lote até que o modelo seja executado com êxito. Alterar o tamanho do lote de um modelo requer o ajuste de outros hiperparâmetros para conseguir a mesma acurácia, como a taxa de aprendizado. No entanto, isso precisa ser avaliado de acordo com o caso.

Tamanhos de camada muito pequenos

Descrição do problema de desempenho

Mesmo quando as convoluções ou multiplicações de matrizes são predominantes no modelo, a TPU pode não funcionar com eficiência total se os tensores de entrada forem pequenos. Em comparação a outros hardwares, a TPU é executada com mais eficiência quando o tamanho do lote e os tamanhos da camada são grandes. Por exemplo, dimensão ≥ 512.

Como saber se o modelo foi afetado

Como regra geral, os tamanhos de camada menores que 128 geram baixa eficiência na TPU. Isso acontece porque 128 é a dimensão nativa da unidade de multiplicação de matriz da TPU. Nas camadas completamente conectadas, o tamanho mínimo oculto de 512 é recomendado para gerar alta eficiência. As camadas convolucionais normalmente não precisam ser tão grandes quanto as completamente conectadas para atingir o mesmo nível de eficiência. Por exemplo, uma convolução 3 × 3 de tamanho 256 atinge eficiência similar (alta) em comparação com uma camada completamente conectada de tamanho 2048, já que 3 × 3 × 256 = 2304.

Como mitigar

Se os tamanhos pequenos de camada no modelo forem motivados principalmente pela velocidade do treinamento, recomendamos que você faça novamente a comparação dos modelos com camadas maiores na TPU. Por exemplo, dobrar o tamanho da saída de uma camada de 256 para 512 só aumenta o tempo de treinamento em 20%, mesmo que o modelo execute duas vezes a computação.

Criação de perfil de modelo no nível operacional

Geralmente, é bom medir o uso de memória e tempo de execução no nível operacional para identificar gargalos de desempenho. Para ver instruções sobre como fazer isso,
consulte o guia Ferramentas da Cloud TPU: visualizador de rastreamento.

Como depurar quedas na acurácia do modelo

Um dos objetivos do ecossistema da Cloud TPU é que qualquer modelo treinado atualmente em uma CPU ou GPU atinja uma acurácia muito semelhante no treinamento na TPU, com pequenos ajustes em hiperparâmetros como o tamanho do lote e a taxa de aprendizado. No entanto, os usuários às vezes observam uma queda na acurácia ao treinar modelos na TPU. A depuração desses problemas pode ser muito frustrante devido à natureza aleatória do treinamento da rede neural. Veja nesta seção orientações sobre como identificar a principal causa de qualquer queda na acurácia ao fazer a portabilidade um modelo para a TPU.

Noções básicas sobre fragmentação de dados (paralelismo)

Um dos principais objetivos do TensorFlow é fazer as operações produzirem resultados quase idênticos, sejam elas executadas em CPU, GPU ou TPU. Há certas exceções, como as operações aleatórias. Em geral, se você encontrar qualquer diferença significativa entre a saída de operações não aleatórias na TPU e na CPU, denuncie como um bug.

No entanto, no pipeline de treinamento como um todo, há uma grande diferença entre o treinamento na CPU/GPU e na TPU: ao usar TPUEstimator e use_tpu=False, o TensorFlow retorna ao mecanismo de execução padrão. Esse mecanismo treina um lote por etapa. Porém, ao treinar na TPU verdadeira, o TensorFlow faz a fragmentação de dados, também conhecida como "paralelismo de dados com GDE síncrono". Isso acontece porque cada Cloud TPU é formada por 8 núcleos que funcionam como unidades de processamento independentes. Portanto, em cada etapa do treinamento, todos os núcleos de TPU recebem um lote de dados, calculam os gradientes de peso, trocam esses gradientes entre si e então calculam a atualização de peso. Por padrão, a média de perda é calculada nos núcleos, mas é possível somá-la alterando o parâmetro de CrossShardOptimizer.

Se for possível calcular a perda total do modelo como a média ou soma de perdas independentes por amostra, este procedimento será matematicamente similar ao treinamento em um único lote grande. A operação mais comum que não é independente por amostra é a normalização de lote, que é executada em cada lote por núcleo separadamente. Por exemplo, se o tamanho total do lote for 128, o tamanho por núcleo será 16. Cada um dos 8 núcleos executará a normalização de lote nas 16 amostras. Em alguns casos, há queda na precisão ao executar a normalização em lotes pequenos. Por exemplo, menos de 32. No cenário ideal, o tamanho total do lote ao realizar treinamentos na TPU pode ser grande. Por exemplo, de 256 a 1024. Portanto, lotes desse tamanho não são um grande problema. No entanto, se esse tamanho for muito grande para caber na memória, será necessário avaliar o efeito da fragmentação de acordo com o caso.

Por conta das complexidades geradas pela fragmentação, a primeira etapa para depurar quedas na acurácia do modelo é executar um treinamento de TPU determinista e de núcleo único. Depois, basta compará-lo a um modelo treinado na CPU/GPU. Geralmente, isso é feito rapidamente porque não requer o treinamento de um modelo para convergência.

Treinamento determinista

Um motivo da dificuldade em depurar diferenças na acurácia do modelo é que o TensorFlow usa diferentes inicialização de peso e embaralhamento de dados sempre que um modelo é treinado. É bom modificar o procedimento de treinamento para ser determinista. Assim, várias execuções produzirão modelos quase idênticos. Nesta seção, você aprende a executar o tutorial do MNIST com determinismo:

  1. Gere um arquivo de checkpoint inicial ao executar uma única etapa na CPU. Essa etapa é usada para conseguir a inicialização de peso determinista. Isso também pode ser conseguido ao sugerir inicializadores de variáveis, mas é mais difícil.
# Run training for 1 step to create an initial checkpoint.
python mnist_tpu.py \
  --use_tpu=False \
  --data_dir=${STORAGE_BUCKET}/data/ \
  --model_dir=${STORAGE_BUCKET}/init_output \
  --random_seed=12345 \
  --iterations=1
  --train_steps=1
  1. Modifique as funções de embaralhamento de dados na função de entrada para usar uma sugestão aleatória. Isso já foi feito no tutorial do MNIST. É algo que funciona para as operações de processamento de dados de entrada porque elas são sempre executadas na CPU. As operações aleatórias na função do modelo podem não ser deterministas entre a TPU e a CPU. Por exemplo:
# In the flag definitions
tf.flags.DEFINE_integer("batch_size", None, "Random seed for training")

# In the input_fn
if FLAGS.random_seed is not None:
dataset = dataset.shuffle(seed=FLAGS.random_seed)
  1. Execute o mesmo modelo duas vezes na CPU para verificar se o treinamento é determinista. É necessário executá-lo em um número razoável de etapas. Por exemplo, 1000. No entanto, ele não precisa ser executado para convergência, já que isso é muito lento na CPU.

    Como o treinamento na CPU é parecido com um treinamento de núcleo único na TPU, use um tamanho de lote que caiba em um único núcleo de TPU. Normalmente, é o tamanho total do lote dividido por 8. O TensorFlow não garante o determinismo bit a bit entre as execuções, mas a perda será muito parecida:
# Copy the initial weights
gsutil mkdir ${STORAGE_BUCKET}/cpu_output_1
gsutil cp -f ${STORAGE_BUCKET}/init_output/* ${STORAGE_BUCKET}/cpu_output_1
gsutil mkdir ${STORAGE_BUCKET}/cpu_output_2
gsutil cp -f ${STORAGE_BUCKET}/init_output/* ${STORAGE_BUCKET}/cpu_output_2

# Run 1
python mnist_tpu.py \
  --use_tpu=False \
  --data_dir=${STORAGE_BUCKET}/data/ \
  --model_dir=${STORAGE_BUCKET}/cpu_output_1 \
  --batch_size=128 \
  --random_seed=12345 \
  --train_steps=2000 \
  --eval_steps=10

# Output 1
accuracy = 0.9910644, global_step = 1000, loss = 0.025323588

# Run 2
python mnist_tpu.py \
  --use_tpu=False \
  --data_dir=${STORAGE_BUCKET}/data/ \
  --model_dir=${STORAGE_BUCKET}/cpu_output_1 \
  --batch_size=128 \
  --random_seed=12345 \
  --train_steps=2000 \
  --eval_steps=10

# Output 2
accuracy = 0.9910644, global_step = 1000, loss = 0.025323414

Treinamento de núcleo único na TPU

Depois que for possível executar o tutorial do MNIST com determinismo, a próxima etapa é replicar os resultados treinados pela CPU na TPU. Você usa um único núcleo de TPU para identificar se o problema está relacionado à fragmentação de dados ou ao próprio mecanismo de execução da TPU.

Veja como executar uma avaliação e treinamento de núcleo único no tutorial do MNIST:

# Use the same weight initialization as the CPU
gsutil cp -f ${STORAGE_BUCKET}/init_output/* ${STORAGE_BUCKET}/tpu_output

# Run training for 1000 steps
python mnist.py \
    --use_tpu=True \
    --master=$GRPC_SERVER \
    --train_file=${STORAGE_BUCKET}/data/train.tfrecords \
    --model_dir=${STORAGE_BUCKET}/tpu_output \
    --random_seed=12345 \
    --batch_size=128 \
    --train_steps=1000 \
    --eval_steps=10

  accuracy = 0.9910644, global_step = 1000, loss = 0.02514153

A perda não corresponderá exatamente ao modelo treinado pela CPU, mas será parecida. Caso contrário, isso indicará que você encontrou um bug no mecanismo de execução da TPU. Antes de enviar um relatório de bug, verifique o seguinte:

  1. Se você está passando num_shards=1 para TPUConfig.

  2. Se você não tem operações aleatórias na função do modelo e se qualquer operação aleatória na função de entrada está sendo sugerida corretamente.

  3. Se você está usando o mesmo arquivo de checkpoint inicial no treinamento da CPU e da TPU.

Como depurar o treinamento da TPU de vários núcleos

Se o modelo tem a mesma perda na CPU e na TPU de núcleo único, o problema é provavelmente um dos seguintes:

(a) A degradação é por conta da variância aleatória natural ao treinar modelos neurais com diferentes inicializações.

(b) A degradação é por conta de um problema relacionado à fragmentação de dados na TPU.

Para determinar se (a) é o problema, treine novamente o modelo completo na CPU/GPU e na TPU de vários núcleos usando a mesma inicialização de peso, como mostrado acima.

Se você tiver certeza de que a queda na acurácia tem significância estatística, estes são os problemas mais prováveis relacionados à fragmentação de dados:

  1. Se o modelo calcula a perda como a soma dos erros por amostra, passe reduction=losses.Reduction.SUM para CrossShardOptimizer. Por padrão, CrossShardOptimizer calcula a média das perdas, em vez da soma.
  2. Se o modelo usa a normalização de lote, um tamanho total de lote menor que 256 (por exemplo, menos de 32 por núcleo) pode reduzir a acurácia.
  3. Se o modelo tem uma função de perda por lote, ele será afetado pela fragmentação. Essas funções costumam ser muito especializadas. Por exemplo, Karras e outros autores (2017) (em inglês) usam um discriminador de lotes ao treinar uma rede adversária generativa.
Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.