Ajuda a proteger a Grande Barreira de Corais com TensorFlow em Kaggle Junte Desafio

Otimize o desempenho do TensorFlow usando o Profiler

Este guia demonstra como usar as ferramentas disponíveis com o TensorFlow Profiler para rastrear o desempenho dos seus modelos do TensorFlow. Você aprenderá como entender o desempenho do seu modelo no host (CPU), no dispositivo (GPU) ou em uma combinação do host e do (s) dispositivo (s).

A criação de perfil ajuda a entender 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, em última análise, agilizar a execução do modelo.

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 o seu perfil de desempenho do modelo em nuvem TPUs, consulte o guia Nuvem TPU .

Instale o Profiler e os pré-requisitos de GPU

Instale o plug-in Profiler para TensorBoard com pip. Observe que o Profiler requer as versões mais recentes do TensorFlow e TensorBoard (> = 2.2).

pip install -U tensorboard_plugin_profile

Para criar um perfil na GPU, você deve:

  1. Conheça os drivers NVIDIA GPU e requisitos CUDA® Toolkit listados em requisitos de software apoio TensorFlow GPU .
  2. Certifique-se as Ferramentas NVIDIA® CUDA® de perfil de Interface (CUPTI) existe no caminho:

    /sbin/ldconfig -N -v $(sed 's/:/ /g' <<< $LD_LIBRARY_PATH) | \
    grep libcupti
    

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

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

Em seguida, executar o ldconfig comando acima novamente para verificar se a biblioteca CUPTI é encontrado.

Resolva problemas de privilégio

Quando você executa perfilar com CUDA® Toolkit em um ambiente Docker ou no Linux, você pode encontrar problemas relacionados com a insuficiência de privilégios CUPTI ( CUPTI_ERROR_INSUFFICIENT_PRIVILEGES ). Ir para os Docs Desenvolvedores da NVIDIA para saber mais sobre como você pode resolver esses problemas em 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 na TensorBoard, que aparece somente depois de ter capturado alguns dados 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
  • TensorFlow Stats
  • Visualizador de rastreamento
  • GPU Kernel Stats
  • Ferramenta de Perfil de Memória
  • Visualizador de pod

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 seu desempenho do 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 os dados de entrada.
      • Saída: Tempo gasto lendo os 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.

  • -Tempo Passo Gráfico: exibe um gráfico de tempo da fase de dispositivo (em milissegundos) ao longo de todos os passos da amostra. 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.

  • Top 10 operações TensorFlow no dispositivo (por exemplo GPU): mostra a ops no dispositivo que corriam o mais longo.

    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.

  • Run Ambiente: Exibe um resumo de alto nível do ambiente 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 Próximo passo: Relatórios quando um modelo é a entrada amarrado e recomenda ferramentas que você pode usar para localizar e gargalos de desempenho modelo de determinação.

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 o pipeline de entrada.

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

  1. Leitura do 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. Uma aplicação é considerado entrada ligada quando se passa uma parte significativa do tempo na calha 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 lado do dispositivo e do host para depurar gargalos de desempenho em qualquer estágio do pipeline de entrada.

Verifique 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 gasoduto de entrada, selecione Perfil, 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 pedido for input amarrado e, em caso afirmativo, por quanto.
  2. Análise do lado do dispositivo: Mostra detalhados, os resultados da análise do dispositivo do lado do dispositivo, incluindo o passo de tempo e do intervalo de tempo gasto dispositivo de espera para os dados de entrada entre os núcleos em cada passo.
  3. Análise do lado do host: mostra uma análise detalhada no lado do host, incluindo uma discriminação do tempo de processamento de entrada no host.

Resumo do pipeline de entrada

O Resumo informa se o seu programa é a entrada ligada ao apresentar a porcentagem de tempo dispositivo gasto em espera para a 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 e no host e quanto tempo do dispositivo foi gasto esperando os dados de entrada do host.

  1. Passo tempo plotados contra número passo: exibe um gráfico de tempo da fase de dispositivo (em milissegundos) ao longo de todos os passos da amostra. 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 tempo de passo: Relatórios a média, desvio padrão, e gama ([mínimo, máximo]), do tempo de passo dispositivo.

Análise do lado do host

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

  • Leitura de dados de arquivos sob demanda: Tempo gasto na leitura de dados de arquivos sem cache, pré-busca, e intercalação.
  • Leitura de dados a partir de arquivos de antecedência: Tempo gasto lendo arquivos, incluindo caching, pré-busca, e intercalação.
  • Dados pré-processamento: Tempo gasto em ops pré-processamento, tais como descompressão imagem.
  • Enqueuing dados a serem transferidos para o dispositivo: Tempo gasto colocar dados para uma fila de alimentação antes de transferir os dados para o dispositivo.

Expandir Op Estatísticas de entrada para inspecionar as estatísticas para ops de entrada individuais e suas categorias discriminadas por tempo de execução.

imagem

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

  1. Op Entrada: mostra o nome op TensorFlow da op entrada.
  2. Contagem: mostra o número total de casos de execução op durante o período de criação de perfis.
  3. Tempo total (em ms): Mostra a soma cumulativa de tempo gasto em cada um desses casos.
  4. Tempo Total%: mostra o tempo total gasto em um op como uma fracção do tempo total gasto no processamento de entrada.
  5. Total de Auto Tempo (em ms): Mostra a soma cumulativa do tempo auto gasto em cada um desses casos. 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. Total de Auto Tempo%. 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 execução automática 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 execução automática de cada tipo de operação no dispositivo.
  • O painel inferior mostra uma tabela que relata dados sobre as 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 a partir 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 identificar problemas de desempenho em seu modelo e, em seguida, executar etapas para resolvê-los. Por exemplo, em um alto nível, você pode identificar se o treinamento de entrada ou modelo está demorando 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 Timeline: Mostra ops que o dispositivo eo host executado ao longo do tempo.
  2. Painel de detalhes: Shows informações adicionais para ops selecionados no painel Timeline.

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

  1. Top bar: Contém vários controles auxiliares.
  2. Tempo Axis: Shows tempo em relação ao início do traço.
  3. Seção e pista rótulos: Cada seção contém várias faixas e tem um triângulo à esquerda que você pode clicar para expandir e fechar a seção. Existe uma seção para cada elemento de processamento no sistema.
  4. Selector ferramenta: Contém várias ferramentas para interagir com o visualizador de rastreamento, tais como Zoom, Pan, Select e sincronismo. Use a ferramenta Timing para marcar um intervalo de tempo.
  5. Eventos: Estes mostram o tempo durante o qual um op foi executado ou a duração da meta-eventos, como etapas de treinamento.
Seções e trilhas

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

  • Uma secção de cada nó do dispositivo, identificado com o número do chip 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:
    • Passo: Mostra a duração das etapas de treinamento que estavam em execução no dispositivo
    • TensorFlow Ops: mostra o ops executados no dispositivo
    • XLA oper: Mostra XLA operações (ops) que corria no dispositivo se XLA é utilizado o compilador (cada op TensorFlow se traduz em uma ou várias operações XLA compilador A XLA traduz os po de XLA em código que é executado no dispositivo.).
  • Uma seção de threads em execução na CPU do computador central, denominada "Threads de host". 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 o tf.profiler.experimental.start API, você pode ativar Python rastreamento usando a ProfilerOptions namedtuple ao iniciar profiling. Alternativamente, se você usar o modo de amostragem para perfilar, você pode selecionar o nível de rastreio usando as opções suspensas na caixa de diálogo Captura perfil.

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 bloco expressa como blockDim.x, blockDim.y, blockDim.z .
    • As dimensões da grade expressa como gridDim.x, gridDim.y, gridDim.z .
    • Se o op é elegível para usar Tensor Cores .
    • Se o kernel contém instruções do Tensor Core.
    • 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 decorrido da GPU em microssegundos.
    • O tempo máximo decorrido da GPU em microssegundos.

Ferramenta de perfil de memória

Os monitores da ferramenta Perfil da memória do uso de memória do seu dispositivo durante o intervalo de profiling. 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 quando você executar multi-tenancy inferência.
  • Depure 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 decomposiçã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 Memória: Dropdown que lista todos os sistemas de memória disponível no dispositivo. 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 perfis.
  3. #Deallocation: O número de deallocations de memória no intervalo 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 uso de memória de pico (em gibs) desde que o modelo começou a correr.
  6. O pico de uso de memória: A utilização da memória de pico (em gibs) no intervalo de perfis. Este campo contém os seguintes subcampos:
    1. Timestamp: O timestamp de quando o uso de memória de pico ocorreu no Graph Timeline.
    2. Pilha Reserva: quantidade de memória reservada para a pilha (em gibs).
    3. Alocação de pilha: 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 percentagem de fragmentação (inferior é melhor). É calculado como uma porcentagem de (1 - Size of the largest chunk of free memory / Total free memory) .

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): O local do evento selecionado na linha do tempo.
  • Evento: O tipo de evento (alocação ou desalocação).
  • requested_size (gibs): A quantidade de memória solicitada. Este será um número negativo para eventos de desalocação.
  • allocation_size (gibs): a quantidade real de memória alocada. Este será um número negativo para eventos de desalocação.
  • tf_op: A op TensorFlow que solicita a alocação / desalocação.
  • step_id: A etapa de formação em que esse evento ocorreu.
  • REGION_TYPE: O tipo de entidade de dados que essa memória alocada é para. Os valores possíveis são temp para temporários, output de activações e gradientes, e persist / dynamic para os pesos e constantes.
  • data_type: O tipo de elemento tensor (por exemplo, para uint8 inteiro de 8 bits sem sinal).
  • tensor_shape: A forma do tensor sendo alocado / desalocada.
  • memory_in_use (gibs): A memória total que está em uso neste momento do tempo.

Tabela de decomposição de memória

Esta tabela mostra as alocações de memória ativa no ponto de pico de uso da 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 Op: O nome da op TensorFlow.
  • Alocação Size (gibs): A quantidade total de memória alocada para esta op.
  • Tamanho solicitado (gibs): A quantidade total de memória solicitada para esta op.
  • Ocorrências: O número de alocações para esta op.
  • Tipo de Região: O tipo de entidade de dados que essa memória alocada é para. Os valores possíveis são temp para temporários, output de activações e gradientes, e persist / dynamic para os pesos e constantes.
  • Tipo de dados: O tipo de elemento tensor.
  • Forma: A forma dos tensores alocados.

Visualizador de pod

A ferramenta Pod Viewer mostra a divisão de uma etapa de treinamento em todos os trabalhadores.

imagem

  • O painel superior possui um controle deslizante para selecionar o número da etapa.
  • O painel inferior exibe um gráfico de colunas empilhadas. Esta é uma visão de alto nível das categorias de tempo de etapa divididas, colocadas umas sobre as outras. Cada coluna empilhada representa um trabalhador único.
  • Quando você passa o mouse sobre uma coluna empilhada, o cartão do lado esquerdo mostra mais detalhes sobre a divisão da etapa.

análise de gargalo tf.data

O tf.data ferramenta de análise de gargalo detecta automaticamente gargalos em tf.data dutos de entrada no seu programa e fornece recomendações sobre como corrigi-los. Ele funciona com qualquer programa usando tf.data independentemente da plataforma (CPU / GPU / TPU). Sua análise e recomendações são baseadas neste guia .

Ele detecta um gargalo seguindo estas etapas:

  1. Encontre o host com maior limite de entrada.
  2. Encontre a execução mais lenta de um tf.data gasoduto de entrada.
  3. Reconstrua o gráfico do pipeline de entrada a partir do rastreamento do criador de perfil.
  4. Encontre o caminho crítico no gráfico do pipeline de entrada.
  5. Identifique a transformação mais lenta no caminho crítico como um gargalo.

A interface do usuário é dividido em três seções: Resumo Análise de Desempenho, resumo de todas Input Dutos e Input Pipeline Gráfico.

Resumo da análise de desempenho

imagem

Esta seção fornece o resumo da análise. Ele relata lentas tf.data dutos de entrada detectados no perfil. Esta seção também mostra o host de maior limite de entrada e seu pipeline de entrada mais lento com a latência máxima. Mais importante ainda, ele identifica qual parte do pipeline de entrada é o gargalo e como corrigi-lo. As informações de gargalo são fornecidas com o tipo de iterador e seu nome longo.

Como ler o nome longo do iterador tf.data

Um nome longo é formatado como Iterator::<Dataset_1>::...::<Dataset_n> . No longo nome, <Dataset_n> corresponde ao tipo iterator e os outros conjuntos de dados no nome longo representam transformações jusante.

Por exemplo, considere o seguinte conjunto de dados do pipeline de entrada:

dataset = tf.data.Dataset.range(10).map(lambda x: x).repeat(2).batch(5)

Os nomes longos para os iteradores do conjunto de dados acima serão:

Tipo de Iterador Nome Longo
Faixa Iterator :: Batch :: Repeat :: Map :: Range
Mapa Iterator :: Lote :: Repetir :: Mapa
Repetir Iterator :: Lote :: Repetir
Lote Iterator :: Batch

Resumo de todos os pipelines de entrada

imagem

Esta seção fornece o resumo de todos os pipelines de entrada em todos os hosts. Normalmente, há um pipeline de entrada. Quando usando a estratégia de distribuição, existe uma tubagem de entrada de acolhimento de executar o programa de tf.data código e várias condutas de entrada dispositivo de recuperação de dados a partir da tubagem de entrada de acolhimento e transferi-lo para os dispositivos.

Para cada pipeline de entrada, ele mostra as estatísticas de seu tempo de execução. Uma chamada é considerada lenta se demorar mais de 50 μs.

Gráfico de pipeline de entrada

imagem

Esta seção mostra o gráfico do pipeline de entrada com as informações do tempo de execução. Você pode usar "Host" e "Pipeline de entrada" para escolher qual host e pipeline de entrada ver. Execuções do pipeline de entrada são classificadas segundo o tempo de execução na ordem que você pode escolher usar o Posto suspensa descendente.

imagem

Os nós do caminho crítico têm contornos ousados. O nó gargalo, que é o nó com o tempo próprio mais longo no caminho crítico, tem um contorno vermelho. Os outros nós não críticos têm contornos cinza tracejados.

Em cada nó, Start Time indica o tempo de início da execução. A mesma n pode ser executada várias vezes, por exemplo, se houver um Batch op na conduta de entrada. Se for executado várias vezes, é a hora de início da primeira execução.

Duração Total é o momento parede da execução. Se for executado várias vezes, é a soma dos tempos da parede de todas as execuções.

Auto Tempo é Tempo total sem o tempo sobreposta com seus nós filho imediato.

"# Chamadas" é o número de vezes que o pipeline de entrada é executado.

Colete dados de desempenho

O TensorFlow Profiler coleta atividades de host e traços de GPU do seu modelo do 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.

  • Modo programático usando o TensorBoard Keras Callback ( tf.keras.callbacks.TensorBoard )

    # 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 o tf.profiler API Função

    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 sob demanda de perfis usando tf.profiler.experimental.server.start para iniciar um servidor gRPC com o seu modelo TensorFlow prazo. Depois de iniciar o servidor gRPC e executando o seu modelo, você pode capturar um perfil através do botão Perfil Captura no plugin perfil TensorBoard. Use o script na seção Instalar criador de perfil acima para iniciar uma instância do TensorBoard, se ainda não estiver em execução.

    Como um exemplo,

    # Start a profiler server before your model runs.
    tf.profiler.experimental.server.start(6009)
    # (Model code goes here).
    #  Send a request to the profiler server to collect a trace of your model.
    tf.profiler.experimental.client.trace('grpc://localhost:6009',
                                          'gs://your_tb_logdir', 2000)
    

    Um exemplo de criação de perfil de vários trabalhadores:

    # E.g. your worker IP addresses are 10.0.0.2, 10.0.0.3, 10.0.0.4, and you
    # would like to profile for a duration of 2 seconds.
    tf.profiler.experimental.client.trace(
        'grpc://10.0.0.2:8466,grpc://10.0.0.3:8466,grpc://10.0.0.4:8466',
        'gs://your_tb_logdir',
        2000)
    

Use o diálogo Captura perfil para especificar:

  • Uma lista delimitada por vírgulas de URLs de serviço de perfil ou nomes de TPU.
  • Uma duração de criação de perfil.
  • O nível de rastreamento de chamada de função do dispositivo, host e 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 o perfil laços de treinamento personalizado em seu código TensorFlow, instrumento do ciclo de formação com o tf.profiler.experimental.Trace API para marcar os limites passo para a Profiler.

O name argumento é utilizado como um prefixo para os nomes passo, o step_num argumento palavra-chave é anexado nos nomes passo, eo _r argumento palavra-chave faz com que este evento de rastreamento são processadas como um evento passo 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 que você incluir o iterador conjunto de dados dentro do tf.profiler.experimental.Trace contexto para uma análise precisa do gasoduto 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:

  • Vs. local remoto de perfil: Estas são duas formas comuns de configuração do ambiente 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.
  • Profiling vários trabalhadores: Você pode perfil várias máquinas ao utilizar as capacidades de formação distribuídas de TensorFlow.
  • Plataforma de hardware: CPUs perfil, GPUs e TPU.

A tabela abaixo fornece uma visão geral rápida dos casos de uso com suporte do TensorFlow mencionados acima:

API de criação de perfil Local Controlo remoto Múltiplos trabalhadores Plataformas de Hardware
Retorno de chamada do TensorBoard Keras Suportado Não suportado Não suportado CPU, GPU
tf.profiler.experimental start / stop API Suportado Não suportado Não suportado CPU, GPU
tf.profiler.experimental client.trace API Suportado Suportado Suportado CPU, GPU, TPU
API do gerenciador de contexto Suportado Não suportado Não suportado CPU, GPU

Melhores práticas para o 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 pipeline de dados de entrada

Use os dados do [#input_pipeline_analyzer] para otimizar seu pipeline de entrada de dados. Um pipeline de entrada de dados eficiente pode melhorar drasticamente a velocidade de execução do seu modelo, reduzindo o tempo ocioso do dispositivo. Tente incorporar as melhores práticas descritas no desempenho melhor com a API tf.data guia e abaixo para fazer o seu pipeline de entrada de dados mais eficiente.

  • Em geral, paralelizar qualquer operação que não precise ser executada sequencialmente pode otimizar significativamente o pipeline de entrada de dados.

  • Em muitos casos, ajuda alterar a ordem de algumas chamadas ou ajustar os argumentos de forma que funcione melhor para o seu modelo. Ao otimizar o pipeline de dados de entrada, compare apenas o carregador de dados sem as etapas de treinamento e retropropagação para quantificar o efeito das otimizações de forma independente.

  • Tente executar seu modelo com dados sintéticos para verificar se o pipeline de entrada é um gargalo de desempenho.

  • Use tf.data.Dataset.shard para a formação multi-GPU. Certifique-se de fragmentar muito cedo no loop de entrada para evitar reduções no rendimento. Ao trabalhar com TFRecords, certifique-se de fragmentar a lista de TFRecords e não o conteúdo dos TFRecords.

  • Paralelizar vários ops ajustando dinamicamente o valor de num_parallel_calls usando tf.data.AUTOTUNE .

  • Considere limitar o uso de tf.data.Dataset.from_generator como é mais lenta em comparação com ops TensorFlow puros.

  • Considere limitar o uso de tf.py_function como ele não pode ser serializado e não é suportado para ser executado em TensorFlow distribuído.

  • Use tf.data.Options para controlar otimizações estáticas para o pipeline de entrada.

Leia também o tf.data análise de desempenho guia para obter mais orientações sobre como otimizar o seu pipeline de entrada.

Otimize o aumento de dados

Ao trabalhar com dados de imagem, faça o seu aumento de dados mais eficiente, lançando a diferentes tipos de dados após a aplicação de transformações espaciais, como a inversão, recorte, rotação, etc.

Use NVIDIA® DALI

Em alguns casos, como quando você tem um sistema com uma alta proporção de GPU para CPU, todas as otimizações acima podem não ser suficientes para eliminar gargalos no carregador de dados causados ​​por limitações de ciclos de CPU.

Se você estiver usando GPUs NVIDIA® para a visão de computador e aplicações de áudio aprendizagem profunda, considere usar o Data Loading Library ( DALI ) para acelerar o pipeline de dados.

Verifique a NVIDIA® DALI: Operações documentação para uma lista de ops DALI suportados.

Use threading e execução paralela

Ops executado em vários segmentos de CPU com o tf.config.threading API para executá-los mais rápido.

O TensorFlow define automaticamente o número de threads de paralelismo por padrão. O pool de threads disponível para executar operações do TensorFlow depende do número de threads de CPU disponíveis.

Controlar o aumento de velocidade máximo paralelo por um único op usando tf.config.threading.set_intra_op_parallelism_threads . Observe que se você executar vários ops em paralelo, todos eles compartilharão o pool de threads disponível.

Se você tiver ops sem bloqueio independentes (ops com nenhum caminho dirigido entre eles no gráfico), de uso tf.config.threading.set_inter_op_parallelism_threads para executá-los simultaneamente usando o pool de threads disponíveis.

Diversos

Ao trabalhar com modelos menores em GPUs NVIDIA®, você pode definir tf.compat.v1.ConfigProto.force_gpu_compatible=True para forçar todos os tensores de CPU para ser alocado com CUDA memória preso para dar um impulso significativo para o desempenho do modelo. No entanto, tenha cuidado ao usar essa opção para modelos desconhecidos / muito grandes, pois isso pode afetar negativamente o desempenho do host (CPU).

Melhorar o desempenho do dispositivo

Siga as melhores práticas detalhadas aqui e no guia de otimização de desempenho GPU para otimizar o desempenho do modelo TensorFlow no dispositivo.

Se você estiver usando GPUs NVIDIA, registre a GPU e a utilização da memória em um arquivo CSV executando:

nvidia-smi
--query-gpu=utilization.gpu,utilization.memory,memory.total,
memory.free,memory.used --format=csv

Configurar layout de dados

Ao trabalhar com dados que contêm informações de canal (como imagens), otimize o formato de layout de dados para dar preferência aos canais por último (NHWC em vez de NCHW).

Canal-últimos formatos de dados melhorar Tensor Núcleo utilização e fornecer melhorias de desempenho significativas, especialmente em modelos convolucionais quando combinada com AMP. Os layouts de dados NCHW ainda podem ser operados pelo Tensor Cores, mas introduzem sobrecarga adicional devido às operações de transposição automática.

Você pode otimizar o layout de dados a preferir layouts NHWC definindo data_format="channels_last" para camadas como tf.keras.layers.Conv2D , tf.keras.layers.Conv3D e tf.keras.layers.RandomRotation .

Use tf.keras.backend.set_image_data_format para definir o formato de layout de dados padrão para o backend API Keras.

Maximize o cache L2

When working with NVIDIA® GPUs, execute the code snippet below before the training loop to max out the L2 fetch granularity to 128 bytes.

import ctypes

_libcudart = ctypes.CDLL('libcudart.so')
# Set device limit on the current device
# cudaLimitMaxL2FetchGranularity = 0x05
pValue = ctypes.cast((ctypes.c_int*1)(), ctypes.POINTER(ctypes.c_int))
_libcudart.cudaDeviceSetLimit(ctypes.c_int(0x05), ctypes.c_int(128))
_libcudart.cudaDeviceGetLimit(pValue, ctypes.c_int(0x05))
assert pValue.contents.value == 128

Configure GPU thread usage

The GPU thread mode decides how GPU threads are used.

Set the thread mode to gpu_private to make sure that preprocessing does not steal all the GPU threads. This will reduce the kernel launch delay during training. You can also set the number of threads per GPU. Set these values using environment variables.

import os

os.environ['TF_GPU_THREAD_MODE']='gpu_private'
os.environ['TF_GPU_THREAD_COUNT']='1'

Configure GPU memory options

In general, increase the batch size and scale the model to better utilize GPUs and get higher throughput. Note that increasing the batch size will change the model's accuracy so the model needs to be scaled by tuning hyperparameters like the learning rate to meet the target accuracy.

Also, use tf.config.experimental.set_memory_growth to allow GPU memory to grow to prevent all the available memory from being fully allocated to ops that require only a fraction of the memory. This allows other processes which consume GPU memory to run on the same device.

To learn more, check out the Limiting GPU memory growth guidance in the GPU guide to learn more.

Miscellaneous

  • Increase the training mini-batch size (number of training samples used per device in one iteration of the training loop) to the maximum amount that fits without an out of memory (OOM) error on the GPU. Increasing the batch size impacts the model's accuracy—so make sure you scale the model by tuning hyperparameters to meet the target accuracy.

  • Disable reporting OOM errors during tensor allocation in production code. Set report_tensor_allocations_upon_oom=False in tf.compat.v1.RunOptions .

  • For models with convolution layers, remove bias addition if using batch normalization. Batch normalization shifts values by their mean and this removes the need to have a constant bias term.

  • Use TF Stats to find out how efficiently on-device ops run.

  • Use tf.function to perform computations and optionally, enable the jit_compile=True flag ( tf.function(jit_compile=True ). To learn more, go to Use XLA tf.function .

  • Minimize host Python operations between steps and reduce callbacks. Calculate metrics every few steps instead of at every step.

  • Keep the device compute units busy.

  • Send data to multiple devices in parallel.

  • Consider using 16-bit numerical representations , such as fp16 —the half-precision floating point format specified by IEEE—or the Brain floating-point bfloat16 format.

Additional resources

Known limitations

Profiling multiple GPUs on TensorFlow 2.2 and TensorFlow 2.3

TensorFlow 2.2 and 2.3 support multiple GPU profiling for single host systems only; multiple GPU profiling for multi-host systems is not supported. To profile multi-worker GPU configurations, each worker has to be profiled independently. From TensorFlow 2.4 multiple workers can be profiled using the tf.profiler.experimental.client.trace API.

CUDA® Toolkit 10.2 or later is required to profile multiple GPUs. As TensorFlow 2.2 and 2.3 support CUDA® Toolkit versions only up to 10.1, you need to create symbolic links to libcudart.so.10.1 and 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