Esta página foi traduzida pela API Cloud Translation.
Switch to English

Otimize o desempenho do TensorFlow usando o Profiler

Use as ferramentas disponíveis com o Profiler para rastrear o desempenho dos seus modelos do TensorFlow. Veja o desempenho do seu modelo no host (CPU), no dispositivo (GPU) ou em uma combinação de host e dispositivo (s).

A criação de perfil ajuda a compreender o consumo de recursos de hardware (tempo e memória) das várias operações do TensorFlow (ops) em seu modelo e resolver gargalos de desempenho e, por fim, fazer o modelo executar mais rápido.

Este guia o orientará em como instalar o Profiler, as várias ferramentas disponíveis, os diferentes modos de como o Profiler coleta dados de desempenho e algumas práticas recomendadas para otimizar o desempenho do modelo.

Se você quiser traçar o perfil de desempenho do seu modelo em Cloud TPUs, consulte o guia do Cloud TPU .

Instale o Profiler e os pré-requisitos de GPU

Instale o Profiler baixando e executando o script install_and_run.py do repositório GitHub .

Para criar um perfil na GPU, você deve:

  1. Instale o CUDA® Toolkit 10.1 ou mais recente. CUDA® Toolkit 10.1 suporta apenas um único perfil de GPU. Para criar o perfil de várias GPUs, consulte Criar perfis de várias GPUs . Certifique-se de que a versão do driver CUDA® que você instalou é pelo menos 440,33 para Linux ou 441,22 para Windows.
  2. Certifique-se de que CUPTI existe no caminho:
/sbin/ldconfig -N -v $(sed 's/:/ /g' <<< $LD_LIBRARY_PATH) | \
grep libcupti

Se você não tiver CUPTI no caminho, acrescente seu diretório de instalação à variável de ambiente $LD_LIBRARY_PATH executando:

export LD_LIBRARY_PATH=/usr/local/cuda/extras/CUPTI/lib64:$LD_LIBRARY_PATH

Execute o comando ldconfig acima novamente para verificar se a biblioteca CUPTI foi encontrada.

Perfil de várias GPUs

O TensorFlow atualmente oferece suporte a vários perfis de GPU apenas para sistemas de host único. Vários perfis de GPU para sistemas multi-host não são suportados atualmente. Instale o CUDA® Toolkit 10.2 ou posterior para criar o perfil de várias GPUs. Como o TensorFlow é compatível com as versões do CUDA® Toolkit apenas até 10.1, crie links simbólicos para libcudart.so.10.1 e libcupti.so.10.1 .

sudo ln -s /usr/local/cuda/lib64/libcudart.so.10.2 /usr/local/cuda/lib64/libcudart.so.10.1
sudo ln -s /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.2 /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.1

Para criar o perfil de configurações de GPU de vários trabalhadores, crie o perfil de trabalhadores individuais de forma independente.

Resolva problemas de privilégio

Ao executar a criação de perfil com CUDA® Toolkit 10.1 em um ambiente Docker ou no Linux, você pode encontrar problemas relacionados a privilégios CUPTI insuficientes ( CUPTI_ERROR_INSUFFICIENT_PRIVILEGES ). Consulte o NVIDIA Developer Docs para saber mais sobre como você pode resolver esses problemas no Linux.

Para resolver problemas de privilégio CUPTI em um ambiente Docker, execute

docker run option '--privileged=true'

Ferramentas de criação de perfil

Acesse o Profiler a partir da guia Perfil no TensorBoard, que aparece somente depois que você captura alguns dados do modelo.

O Profiler tem uma seleção de ferramentas para ajudar na análise de desempenho:

  • Página de visão geral
  • Analisador de pipeline de entrada
  • Estatísticas do TensorFlow
  • Visualizador de rastreamento
  • Estatísticas do kernel GPU
  • Ferramenta de perfil de memória

Página de visão geral

A página de visão geral fornece uma visão de nível superior de como seu modelo foi executado durante a execução de um perfil. A página mostra uma página de visão geral agregada para o seu host e todos os dispositivos, e algumas recomendações para melhorar o desempenho do treinamento do modelo. Você também pode selecionar hosts individuais na lista suspensa Host.

A página de visão geral exibe os dados da seguinte forma:

imagem

  • Resumo do desempenho - exibe um resumo de alto nível do desempenho do seu modelo. O resumo de desempenho tem duas partes:

    1. Análise do tempo da etapa - divide o tempo médio da etapa em várias categorias de onde o tempo é gasto:

      • Compilação - Tempo gasto compilando kernels
      • Entrada - Tempo gasto lendo dados de entrada
      • Saída - Tempo gasto lendo dados de saída
      • Lançamento do kernel - tempo gasto pelo host para lançar os kernels
      • Tempo de computação do host
      • Tempo de comunicação dispositivo a dispositivo
      • Tempo de computação no dispositivo
      • Todos os outros, incluindo sobrecarga do Python
    2. Precisões de computação do dispositivo - Informa a porcentagem de tempo de computação do dispositivo que usa cálculos de 16 e 32 bits

  • Gráfico de tempo de etapa - exibe um gráfico de tempo de etapa do dispositivo (em milissegundos) em todas as etapas amostradas. Cada etapa é dividida em várias categorias (com cores diferentes) de onde o tempo é gasto. A área vermelha corresponde à parte do tempo em que os dispositivos permaneceram inativos aguardando a entrada de dados do host. A área verde mostra quanto tempo o dispositivo estava realmente funcionando

  • Dez principais operações do TensorFlow no dispositivo - exibe as operações no dispositivo que foram executadas por mais tempo.

    Cada linha exibe o tempo próprio de uma operação (como a porcentagem de tempo gasto por todas as operações), o tempo cumulativo, a categoria e o nome.

  • Ambiente de execução - exibe um resumo de alto nível do ambiente de execução do modelo, incluindo:

    • Número de hosts usados
    • Tipo de dispositivo (GPU / TPU)
    • Número de núcleos do dispositivo
  • Recomendação para as próximas etapas - Relata quando um modelo é limitado pela entrada e recomenda ferramentas que você pode usar para localizar e resolver gargalos de desempenho do modelo

Analisador de pipeline de entrada

Quando um programa TensorFlow lê dados de um arquivo, ele começa na parte superior do gráfico do TensorFlow em um pipeline. O processo de leitura é dividido em vários estágios de processamento de dados conectados em série, onde a saída de um estágio é a entrada para o próximo. Este sistema de leitura de dados é chamado de pipeline de entrada .

Um pipeline típico para leitura de registros de arquivos tem os seguintes estágios:

  1. Leitura de arquivo
  2. Pré-processamento de arquivo (opcional)
  3. Transferência de arquivos do host para o dispositivo

Um pipeline de entrada ineficiente pode tornar seu aplicativo muito lento. Um aplicativo é considerado limite de entrada quando passa uma parte significativa do tempo no pipeline de entrada. Use os insights obtidos do analisador de pipeline de entrada para entender onde o pipeline de entrada é ineficiente.

O analisador de pipeline de entrada informa imediatamente se seu programa está vinculado à entrada e o orienta na análise do dispositivo e do host para depurar gargalos de desempenho em qualquer estágio do pipeline de entrada.

Consulte a orientação sobre o desempenho do pipeline de entrada para as práticas recomendadas para otimizar seus pipelines de entrada de dados.

Painel do pipeline de entrada

Para abrir o analisador de pipeline de entrada, selecione Perfil e , em seguida, selecione input_pipeline_analyzer no menu suspenso Ferramentas .

imagem

O painel contém três seções:

  1. Resumo - resume o pipeline de entrada geral com informações sobre se o seu aplicativo está vinculado à entrada e, em caso afirmativo, por quanto
  2. Análise do lado do dispositivo - Exibe resultados detalhados da análise do lado do dispositivo, incluindo o tempo da etapa do dispositivo e o intervalo de tempo do dispositivo gasto esperando pelos dados de entrada nos núcleos em cada etapa
  3. Análise do lado do host - mostra uma análise detalhada do lado do host, incluindo uma análise do tempo de processamento de entrada no host

Resumo do pipeline de entrada

O Resumo informa se o seu programa é limitado pela entrada, apresentando a porcentagem de tempo do dispositivo gasto na espera da entrada do host. Se você estiver usando um pipeline de entrada padrão que foi instrumentado, a ferramenta informa onde a maior parte do tempo de processamento de entrada é gasto.

Análise do lado do dispositivo

A análise do lado do dispositivo fornece insights sobre o tempo gasto no dispositivo em comparação com o host e quanto tempo do dispositivo foi gasto esperando pelos dados de entrada do host.

  1. Tempo da etapa plotado contra o número da etapa - Exibe um gráfico do tempo da etapa do dispositivo (em milissegundos) em todas as etapas amostradas. Cada etapa é dividida em várias categorias (com cores diferentes) de onde o tempo é gasto. A área vermelha corresponde à parte do tempo em que os dispositivos permaneceram inativos aguardando a entrada de dados do host. A área verde mostra quanto tempo o dispositivo estava realmente funcionando
  2. Estatísticas de tempo da etapa - Informa a média, desvio padrão e intervalo ([mínimo, máximo]) do tempo da etapa do dispositivo

Análise do lado do host

A análise do lado do host relata uma divisão do tempo de processamento de entrada (o tempo gasto nas tf.data API tf.data ) no host em várias categorias:

  • Lendo dados de arquivos sob demanda - Tempo gasto na leitura de dados de arquivos sem armazenamento em cache, pré-busca e intercalação
  • Leitura de dados de arquivos com antecedência - Tempo gasto lendo arquivos, incluindo armazenamento em cache, pré-busca e intercalação
  • Pré-processamento de dados - Tempo gasto em operações de pré-processamento, como descompressão de imagem
  • Enfileiramento de dados a serem transferidos para o dispositivo - Tempo gasto colocando dados em uma fila de alimentação antes de transferir os dados para o dispositivo

Expanda a entrada Op Estatísticas para ver as estatísticas para ops entrada indivíduo e suas categorias discriminadas por tempo de execução.

imagem

Uma tabela de dados de origem aparece com cada entrada contendo as seguintes informações:

  1. Op de entrada - mostra o nome da operação do TensorFlow da operação de entrada
  2. Contagem - mostra o número total de instâncias de execução operacional durante o período de criação de perfil
  3. Tempo total (em ms) - mostra a soma cumulativa do tempo gasto em cada uma dessas instâncias
  4. % De tempo total - mostra o tempo total gasto em uma operação como uma fração do tempo total gasto no processamento de entrada
  5. Tempo próprio total (em ms) - mostra a soma cumulativa do tempo próprio gasto em cada uma dessas instâncias. O tempo próprio aqui mede o tempo gasto dentro do corpo da função, excluindo o tempo gasto na função que ele chama.
  6. % De tempo próprio total . Mostra o tempo próprio total como uma fração do tempo total gasto no processamento de entrada
  7. Categoria Mostra a categoria de processamento da operação de entrada

Estatísticas do TensorFlow

A ferramenta TensorFlow Stats exibe o desempenho de cada TensorFlow op (op) que é executado no host ou dispositivo durante uma sessão de criação de perfil.

imagem

A ferramenta exibe informações de desempenho em dois painéis:

  • O painel superior exibe até quatro gráficos de pizza:

    1. A distribuição do tempo de auto-execução de cada op no host
    2. A distribuição do tempo de auto-execução de cada tipo de operação no host
    3. A distribuição do tempo de auto-execução de cada operação no dispositivo
    4. A distribuição do tempo de auto-execução de cada tipo de operação no dispositivo
  • O painel inferior mostra uma tabela que relata dados sobre operações do TensorFlow com uma linha para cada operação e uma coluna para cada tipo de dados (classifique as colunas clicando no título da coluna). Clique no botão Exportar como CSV no lado direito do painel superior para exportar os dados desta tabela como um arquivo CSV.

    Observe que:

    • Se algum ops tiver ops filho:

      • O tempo total "acumulado" de uma operação inclui o tempo gasto dentro das operações filho

      • O tempo total "próprio" de uma operação não inclui o tempo gasto dentro das operações filho

    • Se uma operação for executada no host:

      • A porcentagem do tempo próprio total no dispositivo incorrido pela operação será 0
      • A porcentagem cumulativa do tempo próprio total no dispositivo até e incluindo esta operação será 0
    • Se uma operação for executada no dispositivo:

      • A porcentagem do tempo próprio total no host incorrido por esta operação será 0
      • A porcentagem cumulativa do tempo próprio total no host até e incluindo esta operação será 0

Você pode optar por incluir ou excluir o tempo ocioso nos gráficos de pizza e na tabela.

Visualizador de rastreamento

O visualizador de rastreamento exibe uma linha do tempo que mostra:

  • Durações para as operações que foram executadas pelo seu modelo TensorFlow
  • Qual parte do sistema (host ou dispositivo) executou uma operação. Normalmente, o host executa operações de entrada, pré-processa os dados de treinamento e os transfere para o dispositivo, enquanto o dispositivo executa o treinamento do modelo real

O visualizador de rastreamento permite que você identifique problemas de desempenho em seu modelo e execute etapas para resolvê-los. Por exemplo, em um alto nível, você pode identificar se o treinamento de entrada ou modelo está levando a maior parte do tempo. Detalhando, você pode identificar quais operações demoram mais para serem executadas. Observe que o visualizador de rastreamento é limitado a 1 milhão de eventos por dispositivo.

Interface do visualizador de rastreamento

Quando você abre o visualizador de rastreamento, ele aparece exibindo sua execução mais recente:

imagem

Esta tela contém os seguintes elementos principais:

  1. Painel da linha do tempo - mostra as operações que o dispositivo e o host executaram ao longo do tempo
  2. Painel de detalhes - mostra informações adicionais para as operações selecionadas no painel da linha do tempo

O painel da linha do tempo contém os seguintes elementos:

  1. Barra superior - contém vários controles auxiliares
  2. Eixo do tempo - mostra o tempo em relação ao início do traço
  3. Rótulos de seção e trilha - cada seção contém várias trilhas e tem um triângulo à esquerda no qual você pode clicar para expandir e recolher a seção. Há uma seção para cada elemento de processamento no sistema
  4. Seletor de ferramentas - contém várias ferramentas para interagir com o visualizador de traços, como zoom, panorâmica, seleção e temporização. Use a ferramenta Timing para marcar um intervalo de tempo.
  5. Eventos - mostram o tempo durante o qual uma operação foi executada ou a duração dos meta-eventos, como etapas de treinamento
Seções e trilhas

O visualizador de rastreamento contém as seguintes seções:

  • Uma seção para cada nó do dispositivo , rotulada com o número do chip do dispositivo e o nó do dispositivo dentro do chip (por exemplo, /device:GPU:0 (pid 0) ). Cada seção de nó de dispositivo contém as seguintes faixas:
    • Etapa - Mostra a duração das etapas de treinamento que foram executadas no dispositivo
    • TensorFlow Ops - . Mostra as operações executadas no dispositivo
    • XLA Ops - mostra as operações XLA (ops) que foram executadas no dispositivo se o XLA for o compilador usado (cada TensorFlow ops é traduzido em um ou vários XLA ops. O compilador XLA traduz as XLA ops em código executado no dispositivo).
  • Uma seção para threads em execução na CPU da máquina host, chamada "Host Threads" . A seção contém uma trilha para cada thread da CPU. Observe que você pode ignorar as informações exibidas ao lado dos rótulos da seção.
Eventos

Os eventos na linha do tempo são exibidos em cores diferentes; as cores em si não têm um significado específico.

O visualizador de rastreamento também pode exibir rastros de chamadas de função Python em seu programa TensorFlow. Se você usar a API tf.profiler.experimental.start() , poderá ativar o rastreamento Python usando ProfilerOptions namedtuple ao iniciar a criação de perfil. Como alternativa, se você usar o modo de amostragem para criação de perfil, poderá selecionar o nível de rastreio usando as opções suspensas na caixa de diálogo Perfil de captura .

imagem

Estatísticas do kernel GPU

Esta ferramenta mostra estatísticas de desempenho e a operação de origem para cada kernel acelerado por GPU.

imagem

A ferramenta exibe informações em dois painéis:

  • O painel superior exibe um gráfico de pizza que mostra os kernels CUDA que têm o maior tempo total decorrido

  • O painel inferior exibe uma tabela com os seguintes dados para cada par kernel-op exclusivo:

    • Uma classificação em ordem decrescente da duração total decorrida da GPU agrupada por par kernel-op
    • O nome do kernel lançado
    • O número de registros de GPU usados ​​pelo kernel
    • O tamanho total da memória compartilhada (compartilhada estática + dinâmica) usada em bytes
    • A dimensão do bloco expressa como blockDim.x, blockDim.y, blockDim.z
    • As dimensões da grade expressas como gridDim.x, gridDim.y, gridDim.z
    • Se a operação está qualificada para usar TensorCores
    • Se o kernel contém instruções TensorCore
    • O nome do op que lançou este kernel
    • O número de ocorrências deste par kernel-op
    • O tempo total decorrido da GPU em microssegundos
    • O tempo médio decorrido da GPU em microssegundos
    • O tempo mínimo de GPU decorrido em microssegundos
    • O tempo máximo decorrido de GPU em microssegundos

Ferramenta de perfil de memória

A ferramenta Perfil de memória monitora o uso de memória de seu dispositivo durante o intervalo de criação de perfil. Você pode usar esta ferramenta para:

  • Depure problemas de falta de memória (OOM) identificando o pico de uso de memória e a alocação de memória correspondente para operações do TensorFlow. Você também pode depurar problemas OOM que podem surgir ao executar a inferência de multilocação
  • Depurar problemas de fragmentação de memória

A ferramenta de perfil de memória exibe dados em três seções:

  1. Resumo do Perfil de Memória
  2. Gráfico da linha do tempo da memória
  3. Tabela de divisão de memória

Resumo do perfil de memória

Esta seção exibe um resumo de alto nível do perfil de memória do seu programa TensorFlow, conforme mostrado abaixo:

O resumo do perfil de memória tem seis campos:

  1. ID da memória - lista suspensa que lista todos os sistemas de memória do dispositivo disponíveis. Selecione o sistema de memória que deseja visualizar no menu suspenso
  2. #Allocation - O número de alocações de memória feitas durante o intervalo de criação de perfil
  3. #Deallocation - O número de desalocações de memória no intervalo de criação de perfil
  4. Capacidade de memória - A capacidade total (em GiBs) do sistema de memória que você selecionar
  5. Peak Heap Usage - O pico de uso de memória (em GiBs) desde que o modelo começou a ser executado
  6. Peak Memory Usage - O pico de uso de memória (em GiBs) no intervalo de criação de perfil. Este campo contém os seguintes subcampos:
    1. Timestamp - O carimbo de data / hora de quando o pico de uso de memória ocorreu no gráfico da linha do tempo
    2. Reserva de pilha - quantidade de memória reservada na pilha (em GiBs)
    3. Alocação de heap - quantidade de memória alocada no heap (em GiBs)
    4. Memória livre - quantidade de memória livre (em GiBs). A capacidade de memória é a soma total da reserva de pilha, alocação de heap e memória livre
    5. Fragmentação - A porcentagem de fragmentação (quanto menor, melhor). É calculado como uma porcentagem de (1 - Tamanho do maior pedaço de memória livre / Memória livre total)

Gráfico de linha do tempo de memória

Esta seção exibe um gráfico do uso de memória (em GiBs) e a porcentagem de fragmentação em relação ao tempo (em ms).

imagem

O eixo X representa a linha do tempo (em ms) do intervalo de criação de perfil. O eixo Y à esquerda representa o uso de memória (em GiBs) e o eixo Y à direita representa a porcentagem de fragmentação. Em cada ponto no tempo no eixo X, a memória total é dividida em três categorias: pilha (em vermelho), pilha (em laranja) e livre (em verde). Passe o mouse sobre um carimbo de data / hora específico para visualizar os detalhes sobre os eventos de alocação / desalocação de memória naquele ponto, como abaixo:

imagem

A janela pop-up exibe as seguintes informações:

  • timestamp (ms) - A localização do evento selecionado na linha do tempo
  • evento - O tipo de evento (alocação ou desalocação)
  • request_size (GiBs) - A quantidade de memória solicitada. Este será um número negativo para eventos de desalocação
  • ocation_size (GiBs) - A quantidade real de memória alocada. Este será um número negativo para eventos de desalocação
  • tf_op - O TensorFlow Op que solicita a alocação / desalocação
  • step_id - A etapa de treinamento em que este evento ocorreu
  • region_type - o tipo de entidade de dados para o qual esta memória alocada se destina. Os valores possíveis são temp para temporários, output para ativações e gradientes e persist / dynamic para pesos e constantes
  • data_type - o tipo de elemento tensor (por exemplo, uint8 para inteiro sem sinal de 8 bits)
  • tensor_shape - A forma do tensor sendo alocado / desalocado
  • memory_in_use (GiBs) - A memória total que está em uso neste momento

Tabela de decomposição de memória

Esta tabela mostra as alocações de memória ativa no ponto de pico de uso de memória no intervalo de criação de perfil.

imagem

Há uma linha para cada TensorFlow Op e cada linha tem as seguintes colunas:

  • Nome da operação - o nome da operação do TensorFlow
  • Tamanho de alocação (GiBs) - A quantidade total de memória alocada para esta operação
  • Tamanho solicitado (GiBs) - A quantidade total de memória solicitada para esta operação
  • Ocorrências - o número de alocações para esta operação
  • Tipo de região - O tipo de entidade de dados para a qual esta memória alocada se destina. Os valores possíveis são temp para temporários, output para ativações e gradientes e persist / dynamic para pesos e constantes
  • Tipo de dados - o tipo de elemento tensor
  • Forma - A forma dos tensores alocados

Colete dados de desempenho

O TensorFlow Profiler coleta atividades de host e traços de GPU do seu modelo TensorFlow. Você pode configurar o Profiler para coletar dados de desempenho por meio do modo programático ou do modo de amostragem.

APIs de criação de perfil

Você pode usar as seguintes APIs para realizar a criação de perfil.

# Profile from batches 10 to 15
tb_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir,
                                             profile_batch='10, 15')

# Train the model and use the TensorBoard Keras callback to collect
# performance profiling data
model.fit(train_data,
          steps_per_epoch=20,
          epochs=5,
          callbacks=[tb_callback])
  • Modo programático usando a API de função tf.profiler
tf.profiler.experimental.start('logdir')
# Train the model here
tf.profiler.experimental.stop()
  • Modo programático usando o gerenciador de contexto
with tf.profiler.experimental.Profile('logdir'):
    # Train the model here
    pass
  • Modo de amostragem - execute a criação de perfil sob demanda usando tf.profiler.experimental.server.start() para iniciar um servidor gRPC com o modelo do TensorFlow executado. Depois de iniciar o servidor gRPC e executar seu modelo, você pode capturar um perfil por meio do botão Capturar perfil no plug-in de perfil do TensorBoard. Use o script na seção Instalar criador de perfil acima para iniciar uma instância do TensorBoard se ela ainda não estiver em execução.

    Como um exemplo,

# Start a gRPC server at port 6009
tf.profiler.experimental.server.start(6009)
# ... TensorFlow program ...

Use a caixa de diálogo Capture Profile para especificar:

  • O URL do serviço de perfil ou nome do TPU
  • A duração do perfil
  • O nível de dispositivo, host e rastreamento de chamada de função Python
  • Quantas vezes você deseja que o Profiler tente capturar novamente os perfis se não tiver êxito no início

Criação de perfil de loops de treinamento personalizados

Para criar o perfil dos loops de treinamento personalizados em seu código do TensorFlow, instrumentalize o loop de treinamento com a API tf.profiler.experimental.Trace para marcar os limites das etapas para o Profiler. O argumento name é usado como um prefixo para os nomes das etapas, o argumento da palavra-chave step_num é anexado aos nomes das etapas e o argumento da palavra-chave _r faz com que esse evento de rastreamento seja processado como um evento da etapa pelo Profiler.

Como um exemplo,

for step in range(NUM_STEPS):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_data = next(dataset)
        train_step(train_data)

Isso habilitará a análise de desempenho baseada em etapas do Profiler e fará com que os eventos da etapa apareçam no visualizador de rastreamento.

Certifique-se de incluir o iterador do conjunto de dados no contexto tf.profiler.experimental.Trace para uma análise precisa do pipeline de entrada.

O snippet de código abaixo é um antipadrão:

for step, train_data in enumerate(dataset):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_step(train_data)

Perfis de casos de uso

O profiler cobre vários casos de uso ao longo de quatro eixos diferentes. Algumas das combinações são atualmente suportadas e outras serão adicionadas no futuro. Alguns dos casos de uso são:

  • Perfil local vs. remoto: Estas são duas maneiras comuns de configurar seu ambiente de criação de perfil. Na criação de perfil local, a API de criação de perfil é chamada na mesma máquina que seu modelo está executando, por exemplo, uma estação de trabalho local com GPUs. Na criação de perfil remota, a API de criação de perfil é chamada em uma máquina diferente de onde seu modelo está sendo executado, por exemplo, em um Cloud TPU.
  • Criação de perfil de vários trabalhadores: você pode criar o perfil de várias máquinas ao usar os recursos de treinamento distribuído do TensorFlow.
  • Plataforma de hardware: Perfis de CPUs, GPUs e TPUs.

A tabela abaixo é uma visão geral rápida de quais casos de uso acima são compatíveis com as várias APIs de criação de perfil no TensorFlow 2.3:

API de criação de perfil Local Controlo remoto Vários trabalhadores Plataformas de Hardware
Retorno de chamada do TensorBoard Keras Com suporte Não suportado Não suportado CPU, GPU
API de função tf.experimental.profiler Com suporte Não suportado Não suportado CPU, GPU
API do gerenciador de contexto Com suporte Não suportado Não suportado CPU, GPU
API sob demanda Não suportado Com suporte Suporte limitado CPU, GPU, TPU

Melhores práticas para desempenho ideal do modelo

Use as recomendações a seguir conforme aplicável para seus modelos do TensorFlow para obter o desempenho ideal.

Em geral, execute todas as transformações no dispositivo e certifique-se de usar a versão compatível mais recente de bibliotecas como cuDNN e Intel MKL para sua plataforma.

Otimize o canal de dados de entrada

Um pipeline de entrada de dados eficiente pode melhorar drasticamente a velocidade de execução do modelo, reduzindo o tempo ocioso do dispositivo. Considere incorporar as seguintes práticas recomendadas, conforme detalhado aqui, para tornar o pipeline de entrada de dados mais eficiente:

  • Pré-busca de dados
  • Paralelizar a extração de dados
  • Paralelizar a transformação de dados
  • Dados de cache na memória
  • Vetorizar funções definidas pelo usuário
  • Reduza o uso de memória ao aplicar transformações

Além disso, tente executar seu modelo com dados sintéticos para verificar se o pipeline de entrada é um gargalo de desempenho.

Melhorar o desempenho do dispositivo

  • Aumentar o tamanho do minilote de treinamento (número de amostras de treinamento usadas por dispositivo em uma iteração do loop de treinamento)
  • Use TF Stats para descobrir quão eficientemente as operações no dispositivo são executadas
  • Use tf.function para realizar cálculos e, opcionalmente, habilite o sinalizador experimental_compile
  • Minimize as operações do host Python entre as etapas e reduza os retornos de chamada. Calcule métricas a cada poucas etapas, em vez de a cada etapa
  • Mantenha as unidades de computação do dispositivo ocupadas
  • Envie dados para vários dispositivos em paralelo
  • Otimize o layout de dados para preferir canais primeiro (por exemplo, NCHW em vez de NHWC). Certos GPUs como o NVIDIA® V100 têm melhor desempenho com um layout de dados NHWC.
  • Considere o uso de representações numéricas de 16 bits, como fp16 , o formato de ponto flutuante de meia precisão especificado pelo IEEE ou o formato bfloat16 de ponto flutuante do Brain
  • Considere o uso da API de precisão mista Keras
  • Ao treinar em GPUs, use o TensorCore. Os kernels da GPU usam o TensorCore quando a precisão é fp16 e as dimensões de entrada / saída são divisíveis por 8 ou 16 (para int8)

Recursos adicionais