Medição da performance

Ferramentas de comparativo de mercado

Atualmente, as ferramentas de referência da LiteRT 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 do estado estável
• Uso da memória durante o tempo de inicialização
• Uso geral da memória

As ferramentas de comparação estão disponíveis como aplicativos de referência para Android e iOS e como binários nativos da linha de comando e todos compartilham o mesmo desempenho principal lógica de medição. As opções disponíveis e os formatos de saída são um pouco diferente devido às diferenças no ambiente de execução.

App Android de comparativo de mercado

Há duas opções para usar a ferramenta de comparação com o Android. Uma delas é binário de comparação nativo, e o outro é um binário do Android app de referência, um indicador melhor do desempenho do modelo no app. De qualquer os números da ferramenta de referência ainda serão um pouco diferentes executando inferência com o modelo no app real.

Este app Android de comparativo de mercado não tem interface. Instale e execute usando o adb. e recupere os resultados usando o comando adb logcat.

Fazer o download ou criar o app

Faça o download dos apps Android pré-criados para todas as noites usando os links abaixo:

• android_aarch64
• android_arm

Em relação a apps Android de comparação compatíveis com o TF ops usando o delegado flexível, acesse os links abaixo:

• android_aarch64
• android_arm

Você também pode criar o app a partir da origem seguindo estas instruções.

Preparar a comparação

Antes de executar o app de comparação, instale-o e envie o arquivo do modelo para o dispositivo da seguinte forma:

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

Executar comparação

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 de modelo do TFLite.

É possível especificar mais parâmetros opcionais para executar a comparação.

• num_threads: int (padrão=1)
  O número de linhas de execução que serão usadas para executar o intérprete do TFLite.
• use_gpu: bool (padrão=falso)
  Use o delegado da GPU.
• use_xnnpack: bool (padrão=false)
  Usar delegado XNNPACK.

Dependendo do dispositivo que você estiver usando, algumas destas opções podem não ser disponíveis ou não têm efeito. Consulte parâmetros para mais parâmetros de desempenho que podem ser executados com o app de referência.

Veja os resultados usando o comando logcat:

adb logcat | grep "Inference timings"

Os resultados da comparação são informados como:

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

Binário de comparação nativo

A ferramenta de comparação também é fornecida como um benchmark_model binário nativo. Você pode executar essa ferramenta a partir de uma linha de comando shell no Linux, Mac, dispositivos incorporados e Dispositivos Android.

Fazer o download ou criar o binário

Faça o download dos binários pré-criados de linha de comando nativos noturnos seguindo as links abaixo:

• linux_x86-64;
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

Quanto aos binários pré-criados noturnos com suporte a TF ops usando o delegado flexível, acesse os links abaixo:

• linux_x86-64;
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

Também é possível criar o binário nativo de comparação fonte no seu computador.

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

Para compilar com o conjunto de ferramentas do Android NDK, é necessário configurar o ambiente de compilação primeiro seguindo este guia ou use a imagem Docker, conforme descrito neste .

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

Executar comparação

Para fazer comparações no 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 como mencionado acima, com o binário nativo de linha de comando.

Operações do modelo de criação de perfil

O binário do modelo de referência também permite criar o perfil das operações do modelo e os tempos de execução de cada operador. Para fazer isso, transmita a flag --enable_op_profiling=true para benchmark_model durante a invocação. Os detalhes são explicada aqui.

Binário de comparativo de mercado nativo para várias opções de desempenho em uma única execução

Um binário C++ simples e conveniente também é fornecido para comparar várias opções de desempenho em uma única execução. Esse binário é criado com base na ferramenta de referência mencionada acima. que só possa avaliar uma opção de desempenho por vez. Eles compartilham mesmo processo de compilação/instalação/execução, mas o nome do destino BUILD desse binário é benchmark_model_performance_options e alguns outros parâmetros são necessários. Um parâmetro importante para esse binário é:

perf_options_list: string (default='all')
Uma lista separada por vírgulas de opções de desempenho do TFLite para comparar.

Você pode receber binários pré-criados todas as noites para essa ferramenta, conforme listado abaixo:

• linux_x86-64;
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

App iOS de comparativo de mercado

Para executar comparações no dispositivo iOS, você precisa criar o app a partir de fonte. Coloque o arquivo do modelo LiteRT no benchmark_data da árvore de origem e modifique o arquivo benchmark_params.json. Aqueles os arquivos são empacotados no aplicativo, que lê os dados do diretório. Acessar as App de comparação para iOS para ver instruções detalhadas.

Comparativos de mercado de desempenho para modelos conhecidos

Esta seção lista os comparativos de mercado de desempenho do LiteRT para quando a execução é boa. modelos conhecidos em alguns dispositivos Android e iOS.

Comparativos de mercado de desempenho do Android

Esses números de comparativo de mercado de desempenho foram gerados binário de comparativo de mercado nativo.

Para comparativos de mercado do Android, a afinidade da CPU está definida para usar núcleos grandes no dispositivo. para reduzir a variância (consulte detalhes).

Ele pressupõe que os modelos foram baixados e descompactados para o /data/local/tmp/tflite_models. O binário de comparação é criado usando estas instruções e é considerado que está no diretório /data/local/tmp.

Para executar a comparação:

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 o delegado da GPU, defina --use_gpu=true.

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

Comparativos de mercado de desempenho do iOS

Esses números de comparativo de mercado de desempenho foram gerados App de comparação para iOS.

Para executar comparações para iOS, o app de comparação foi modificado para incluir as informações e benchmark_params.json foi modificado para definir num_threads como 2. Para usar o delegado da GPU, as opções "use_gpu" : "1" e "gpu_wait_type" : "aggressive"; também foram adicionados a benchmark_params.json.

Componentes internos do Trace LiteRT

Componentes internos do Trace LiteRT no Android

Eventos internos do intérprete da LiteRT de um app Android podem ser capturado por Ferramentas de rastreamento do Android. São os mesmos eventos do Android Trace para que a Os eventos capturados do código Java/Kotlin são mostrados com o LiteRT eventos internos.

Alguns exemplos de eventos são:

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

Entre diferentes opções para capturar rastros, este guia aborda os recursos do Android CPU Profiler do Studio e app Rastreamento do sistema. Consulte Ferramenta de linha de comando Perfetto ou Ferramenta de linha de comando Systrace para ver outras opções.

Como adicionar eventos de rastreamento no código Java

Esse é um snippet de código Classificação de imagens aplicativo de exemplo. O intérprete LiteRT é executado na classe Seção recognizeImage/runInference. Esta etapa é opcional, mas é útil para 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 LiteRT

Para ativar o rastreamento LiteRT, defina a propriedade do sistema Android debug.tflite.trace para 1 antes de iniciar o app Android.

adb shell setprop debug.tflite.trace 1

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

Depois de capturar todos os traces, defina o valor da propriedade para desativar o rastreamento. como zero.

adb shell setprop debug.tflite.trace 0

CPU Profiler do Android Studio

Capture rastros com o CPU Profiler do Android Studio siga as etapas abaixo:

1. Selecione Executar > Perfil "app" nos menus superiores.

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

3. Selecione "Rastrear chamadas do sistema" entre os modos de criação de perfil da CPU.

   

4. Pressione "Gravar" .

5. Pressione "Parar" .

6. Investigue o resultado do rastreamento.

   

Neste exemplo, você pode ver a hierarquia de eventos em uma sequência e as estatísticas para cada horário de operador, além de conferir o fluxo de dados de todo o app entre fios

App Rastreamento do sistema

Capture rastros sem o Android Studio seguindo as etapas detalhadas em App Rastreamento do sistema.

Neste exemplo, os mesmos eventos do TFLite foram capturados e salvos no Perfetto. ou Systrace, dependendo da versão do dispositivo Android. O modelo Eles podem ser abertos na interface do Perfetto (link em inglês).

Componentes internos do Trace LiteRT no iOS

Eventos internos do intérprete LiteRT de um app iOS podem ser capturado por Instrumentos incluída no Xcode. São os apps signpost para que os eventos capturados do código Swift/Objective-C sejam vistos juntos com eventos internos do LiteRT.

Alguns exemplos de eventos são:

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

Ativar rastreamento do LiteRT

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

1. Selecione Produto > Esquema > Edit Scheme... nos menus superiores do Xcode.

2. Clique em "Perfil". no painel esquerdo.

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

4. Adicione debug.tflite.trace em "Variáveis de ambiente" nesta seção.

   

Se você quiser excluir eventos do LiteRT ao criar o perfil do app iOS, desativar o rastreamento removendo a variável de ambiente.

Instrumentos de XCode

Siga as etapas abaixo para capturar rastros:

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

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

3. Pressione "Iniciar" .

4. Pressione "Parar" .

5. Clique em "os_signpost" para expandir os itens do subsistema do registro do SO.

6. Clique em "org.tensorflow.lite" subsistema de geração de registros do SO.

7. Investigue o resultado do rastreamento.

   

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

Como usar dados de rastreamento

Os dados de rastreamento permitem identificar gargalos de desempenho.

Aqui estão alguns exemplos de insights que você pode receber 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 inferências linhas de execução, a sobrecarga de programação da CPU poderá levar a um desempenho inferior. É possível reprogramar outras tarefas com uso intensivo da CPU no seu aplicativo para evitar sobrepondo-se à inferência do modelo ou ajustando o número de fios
• Se os operadores não estiverem totalmente delegados, algumas partes do grafo do modelo são executadas na CPU em vez do acelerador de hardware esperado. Você pode substituir os operadores não compatíveis por outros compatíveis.