Medição de desempenho

Ferramentas de referência

As ferramentas de benchmark do TensorFlow Lite atualmente medem e calculam estatísticas para as seguintes métricas de desempenho importantes:

  • Tempo de inicialização
  • Tempo de inferência do estado de aquecimento
  • Tempo de inferência de estado estacionário
  • Uso de memória durante o tempo de inicialização
  • Uso geral de memória

As ferramentas de benchmark estão disponíveis como aplicativos de benchmark para Android e iOS e como binários de linha de comando nativos, e todos compartilham a mesma lógica básica de medição de desempenho. Observe que as opções disponíveis e os formatos de saída são ligeiramente diferentes devido às diferenças no ambiente de tempo de execução.

Aplicativo de referência para Android

Existem duas opções de uso da ferramenta de benchmark com Android. Um é um binário de benchmark nativo e outro é um aplicativo de benchmark Android, uma medida melhor do desempenho do modelo no aplicativo. De qualquer forma, os números da ferramenta de benchmark ainda serão ligeiramente diferentes daqueles da execução da inferência com o modelo no aplicativo real.

Este aplicativo de benchmark Android não possui IU. Instale e execute-o usando o comando adb e recupere os resultados usando o comando adb logcat .

Baixe ou crie o aplicativo

Baixe os aplicativos de benchmark Android pré-construídos noturnos usando os links abaixo:

Quanto aos aplicativos de benchmark Android que suportam operações TF via delegado Flex , use os links abaixo:

Você também pode criar o aplicativo a partir do código-fonte seguindo estas instruções .

Preparar referência

Antes de executar o aplicativo de benchmark, instale-o e envie o arquivo do modelo para o dispositivo da seguinte maneira:

adb install -r -d -g android_aarch64_benchmark_model.apk
adb push your_model.tflite /data/local/tmp

Executar referência

adb shell am start -S \
  -n org.tensorflow.lite.benchmark/.BenchmarkModelActivity \
  --es args '"--graph=/data/local/tmp/your_model.tflite \
              --num_threads=4"'

graph é um parâmetro obrigatório.

  • graph : string
    O caminho para o arquivo do modelo TFLite.

Você pode especificar mais parâmetros opcionais para executar o benchmark.

  • num_threads : int (padrão = 1)
    O número de threads a serem usados ​​para executar o interpretador TFLite.
  • use_gpu : bool (padrão=falso)
    Use o delegado da GPU .
  • use_nnapi : bool (padrão=falso)
    Use o delegado NNAPI .
  • use_xnnpack : bool (padrão = false )
    Use o delegado XNNPACK .
  • use_hexagon : bool (padrão = false )
    Use o delegado Hexagon .

Dependendo do dispositivo que você está usando, algumas dessas opções podem não estar disponíveis ou não ter efeito. Consulte os parâmetros para obter mais parâmetros de desempenho que você pode executar com o aplicativo de benchmark.

Veja os resultados usando o comando logcat :

adb logcat | grep "Inference timings"

Os resultados do benchmark são relatados como:

... tflite  : Inference timings in us: Init: 5685, First inference: 18535, Warmup (avg): 14462.3, Inference (avg): 14575.2

Binário de referência nativo

A ferramenta de benchmark também é fornecida como um benchmark_model binário nativo. Você pode executar esta ferramenta a partir de uma linha de comando shell em Linux, Mac, dispositivos incorporados e dispositivos Android.

Baixe ou construa o binário

Baixe os binários de linha de comando nativos pré-construídos noturnos seguindo os links abaixo:

Quanto aos binários noturnos pré-construídos que suportam operações TF via delegado Flex , use os links abaixo:

Para fazer benchmark com o delegado TensorFlow Lite Hexagon , também pré-construímos os arquivos libhexagon_interface.so necessários (veja aqui para obter detalhes sobre este arquivo). Após baixar o arquivo da plataforma correspondente nos links abaixo, renomeie o arquivo para libhexagon_interface.so .

Você também pode criar o binário de benchmark nativo a partir do código-fonte em seu computador.

bazel build -c opt //tensorflow/lite/tools/benchmark:benchmark_model

Para compilar com o conjunto de ferramentas do Android NDK, você precisa primeiro configurar o ambiente de compilação seguindo este guia ou usar a imagem do Docker conforme descrito neste guia .

bazel build -c opt --config=android_arm64 \
  //tensorflow/lite/tools/benchmark:benchmark_model

Executar referência

Para executar benchmarks em seu computador, execute o binário no shell.

path/to/downloaded_or_built/benchmark_model \
  --graph=your_model.tflite \
  --num_threads=4

Você pode usar o mesmo conjunto de parâmetros mencionado acima com o binário de linha de comando nativo.

Criação de perfil de operações de modelo

O binário do modelo de benchmark também permite criar perfis de operações de modelo e obter os tempos de execução de cada operador. Para fazer isso, passe o sinalizador --enable_op_profiling=true para benchmark_model durante a invocação. Os detalhes são explicados aqui .

Binário de benchmark nativo para múltiplas opções de desempenho em uma única execução

Um binário C++ simples e conveniente também é fornecido para avaliar várias opções de desempenho em uma única execução. Este binário é construído com base na ferramenta de benchmark mencionada, que só pode avaliar uma única opção de desempenho por vez. Eles compartilham o mesmo processo de construção/instalação/execução, mas o nome de destino BUILD deste binário é benchmark_model_performance_options e requer alguns parâmetros adicionais. Um parâmetro importante para este binário é:

perf_options_list : string (padrão='todos')
Uma lista separada por vírgulas de opções de desempenho do TFLite para avaliação de desempenho.

Você pode obter binários pré-construídos todas as noites para esta ferramenta, conforme listado abaixo:

Aplicativo de referência para iOS

Para executar benchmarks em dispositivos iOS, você precisa criar o aplicativo a partir do código-fonte . Coloque o arquivo de modelo do TensorFlow Lite no diretório benchmark_data da árvore de origem e modifique o arquivo benchmark_params.json . Esses arquivos são empacotados no aplicativo e o aplicativo lê os dados do diretório. Visite o aplicativo de benchmark do iOS para obter instruções detalhadas.

Benchmarks de desempenho para modelos bem conhecidos

Esta seção lista benchmarks de desempenho do TensorFlow Lite ao executar modelos conhecidos em alguns dispositivos Android e iOS.

Benchmarks de desempenho do Android

Esses números de benchmark de desempenho foram gerados com o binário de benchmark nativo .

Para benchmarks do Android, a afinidade da CPU é definida para usar grandes núcleos no dispositivo para reduzir a variação (veja detalhes ).

Ele pressupõe que os modelos foram baixados e descompactados no diretório /data/local/tmp/tflite_models . O binário de benchmark é construído usando estas instruções e presume-se que esteja no diretório /data/local/tmp .

Para executar o benchmark:

adb shell /data/local/tmp/benchmark_model \
  --num_threads=4 \
  --graph=/data/local/tmp/tflite_models/${GRAPH} \
  --warmup_runs=1 \
  --num_runs=50

Para executar com delegado nnapi, defina --use_nnapi=true . Para executar com delegado de GPU, defina --use_gpu=true .

Os valores de desempenho abaixo são medidos no Android 10.

Nome do modelo Dispositivo CPU, 4 threads GPU NNAPI
Mobilenet_1.0_224(flutuante) Pixel 3 23,9ms 6,45ms 13,8ms
Pixel 4 14,0ms 9,0ms 14,8ms
Mobilenet_1.0_224 (quant) Pixel 3 13,4ms --- 6,0ms
Pixel 4 5,0ms --- 3,2ms
NASNet móvel Pixel 3 56ms --- 102ms
Pixel 4 34,5ms --- 99,0ms
SqueezeNet Pixel 3 35,8ms 9,5ms 18,5ms
Pixel 4 23,9ms 11,1ms 19,0ms
Inception_ResNet_V2 Pixel 3 422ms 99,8ms 201ms
Pixel 4 272,6ms 87,2ms 171,1ms
Início_V4 Pixel 3 486ms 93ms 292ms
Pixel 4 324,1ms 97,6ms 186,9ms

Benchmarks de desempenho do iOS

Esses números de benchmark de desempenho foram gerados com o aplicativo de benchmark para iOS .

Para executar benchmarks iOS, o aplicativo de benchmark foi modificado para incluir o modelo apropriado e benchmark_params.json foi modificado para definir num_threads como 2. Para usar o delegado GPU, as opções "use_gpu" : "1" e "gpu_wait_type" : "aggressive" foram também adicionado a benchmark_params.json .

Nome do modelo Dispositivo CPU, 2 threads GPU
Mobilenet_1.0_224(flutuante) iPhone XS 14,8ms 3,4ms
Mobilenet_1.0_224 (quant) iPhone XS 11ms ---
NASNet móvel iPhone XS 30,4ms ---
SqueezeNet iPhone XS 21,1ms 15,5ms
Inception_ResNet_V2 iPhone XS 261,1ms 45,7ms
Início_V4 iPhone XS 309ms 54,4ms

Rastrear componentes internos do TensorFlow Lite

Rastrear componentes internos do TensorFlow Lite no Android

Os eventos internos do interpretador TensorFlow Lite de um aplicativo Android podem ser capturados pelas ferramentas de rastreamento do Android . Eles são os mesmos eventos da API Android Trace , portanto, os eventos capturados do código Java/Kotlin são vistos junto com os eventos internos do TensorFlow Lite.

Alguns exemplos de eventos são:

  • Invocação do operador
  • Modificação do gráfico por delegado
  • Alocação de tensores

Entre as diferentes opções para capturar rastros, este guia aborda o Android Studio CPU Profiler e o aplicativo System Tracing. Consulte a ferramenta de linha de comando Perfetto ou a ferramenta de linha de comando Systrace para outras opções.

Incluindo eventos de rastreamento no código Java

Este é um trecho de código do aplicativo de exemplo Classificação de imagens . O interpretador do TensorFlow Lite é executado na seção recognizeImage/runInference . Esta etapa é opcional, mas é útil para ajudar a perceber onde a chamada de inferência é feita.

  Trace.beginSection("recognizeImage");
  ...
  // Runs the inference call.
  Trace.beginSection("runInference");
  tflite.run(inputImageBuffer.getBuffer(), outputProbabilityBuffer.getBuffer().rewind());
  Trace.endSection();
  ...
  Trace.endSection();

Ativar rastreamento do TensorFlow Lite

Para ativar o rastreamento do TensorFlow Lite, defina a propriedade do sistema Android debug.tflite.trace como 1 antes de iniciar o aplicativo Android.

adb shell setprop debug.tflite.trace 1

Se esta propriedade tiver sido definida quando o intérprete do TensorFlow Lite for inicializado, os principais eventos (por exemplo, invocação do operador) do intérprete serão rastreados.

Depois de capturar todos os rastreamentos, desative o rastreamento configurando o valor da propriedade como 0.

adb shell setprop debug.tflite.trace 0

Perfilador de CPU do Android Studio

Capture traces com o Android Studio CPU Profiler seguindo as etapas abaixo:

  1. Selecione Executar> Perfil 'aplicativo' nos menus superiores.

  2. Clique em qualquer lugar na linha do tempo da CPU quando a janela Profiler aparecer.

  3. Selecione 'Trace System Calls' entre os modos de perfil de CPU.

    Selecione 'Rastrear chamadas do sistema'

  4. Pressione o botão 'Gravar'.

  5. Pressione o botão 'Parar'.

  6. Investigue o resultado do rastreamento.

    Rastreamento do Android Studio

Neste exemplo, você pode ver a hierarquia de eventos em um thread e estatísticas para cada horário do operador e também ver o fluxo de dados de todo o aplicativo entre threads.

Aplicativo de rastreamento do sistema

Capture rastreamentos sem o Android Studio seguindo as etapas detalhadas no aplicativo System Tracing .

Neste exemplo, os mesmos eventos TFLite foram capturados e salvos no formato Perfetto ou Systrace dependendo da versão do dispositivo Android. Os arquivos de rastreamento capturados podem ser abertos na UI do Perfetto .

Traço perfeito

Rastrear componentes internos do TensorFlow Lite no iOS

Eventos internos do interpretador TensorFlow Lite de um aplicativo iOS podem ser capturados pela ferramenta Instruments incluída no Xcode. Eles são os eventos de sinalização do iOS, portanto, os eventos capturados do código Swift/Objective-C são vistos junto com os eventos internos do TensorFlow Lite.

Alguns exemplos de eventos são:

  • Invocação do operador
  • Modificação do gráfico por delegado
  • Alocação de tensores

Ativar rastreamento do TensorFlow Lite

Defina a variável de ambiente debug.tflite.trace seguindo as etapas abaixo:

  1. Selecione Produto > Esquema > Editar Esquema... nos menus superiores do Xcode.

  2. Clique em ‘Perfil’ no painel esquerdo.

  3. Desmarque a caixa de seleção 'Usar os argumentos e variáveis ​​de ambiente da ação Executar'.

  4. Adicione debug.tflite.trace na seção 'Variáveis ​​de ambiente'.

    Definir variável de ambiente

Se você quiser excluir eventos do TensorFlow Lite ao criar o perfil do aplicativo iOS, desative o rastreamento removendo a variável de ambiente.

Instrumentos XCode

Capture rastros seguindo as etapas abaixo:

  1. Selecione Produto > Perfil nos menus superiores do Xcode.

  2. Clique em Log entre modelos de criação de perfil quando a ferramenta Instruments for iniciada.

  3. Pressione o botão 'Iniciar'.

  4. Pressione o botão 'Parar'.

  5. Clique em 'os_signpost' para expandir os itens do subsistema OS Logging.

  6. Clique no subsistema de registro do SO 'org.tensorflow.lite'.

  7. Investigue o resultado do rastreamento.

    Rastreamento de instrumentos Xcode

Neste exemplo, você pode ver a hierarquia de eventos e estatísticas para cada horário do operador.

Usando os dados de rastreamento

Os dados de rastreamento permitem identificar gargalos de desempenho.

Aqui estão alguns exemplos de insights que você pode obter do criador de perfil e possíveis soluções para melhorar o desempenho:

  • Se o número de núcleos de CPU disponíveis for menor que o número de threads de inferência, a sobrecarga de agendamento da CPU poderá levar a um desempenho abaixo da média. Você pode reprogramar outras tarefas com uso intensivo de CPU em seu aplicativo para evitar sobreposição com a inferência do modelo ou ajustar o número de threads do interpretador.
  • Se os operadores não forem totalmente delegados, algumas partes do gráfico do modelo serão executadas na CPU em vez do acelerador de hardware esperado. Você pode substituir os operadores não suportados por operadores semelhantes suportados.