Medição da performance

Ferramentas de comparativo de mercado

No momento, as ferramentas de comparativo de mercado do 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 constante
• Uso da memória durante a inicialização
• Uso geral da memória

As ferramentas de comparativo de mercado estão disponíveis como apps para Android e iOS e como binários de linha de comando pré-criados. Todas compartilham a mesma lógica principal de medição de performance. As opções disponíveis e os formatos de saída são um pouco diferentes devido às diferenças no ambiente de execução.

Binário de comparativo pré-criado (usando a API CompiledModel)

Há duas opções de usar a ferramenta de comparativo de mercado com o Android. Um é um binário de comparativo de mercado nativo (baseado na API CompiledModel) e outro é um app de comparativo de mercado do Android (baseado na API Interpreter). A ferramenta de comparativo de mercado do LiteRT é fornecida como um binário integrado benchmark_model. É possível executar essa ferramenta em uma linha de comando do shell no Linux, macOS, Windows, Raspberry Pi, dispositivos incorporados e dispositivos Android com aceleração de GPU ativada.

Baixar ou criar o binário

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

• linux_x86_64
• linux_arm64
• android_arm64
• macos_arm64
• windows_x86_64

Também é possível criar o binário de comparativo de mercado da fonte no seu computador.

bazel build -c opt //litert/tools:benchmark_model

Para criar com o conjunto de ferramentas do NDK do Android, primeiro configure o ambiente de build seguindo este guia ou use a imagem do Docker conforme descrito neste guia.

bazel build -c opt --config=android_arm64 \
  //litert/tools:benchmark_model

Executar comparativo de mercado

Para executar comparativos de mercado no seu computador, execute o binário no shell.

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

É possível usar o mesmo conjunto de parâmetros mencionado anteriormente com o binário de linha de comando pré-criado.

Acelerador de GPU

Esses binários pré-criados incluem o novo acelerador de GPU LiteRT. Ele é compatível com OpenCL e WebGPU com suporte de Vulkan (Linux), Metal (MacOS) e Direct3D (Windows).

Para usar o acelerador de GPU, transmita a flag --use_gpu=true.

Criar perfil das operações de modelo

O binário do modelo de comparativo de mercado também permite criar perfis de operações de modelo e receber os tempos de execução de cada operador. Para fazer isso, transmita a flag --use_profiler=true para benchmark_model durante a invocação.

App de comparativo de mercado do Android (usando a API Interpreter)

Um app de comparativo de mercado do Android baseado na API Interpreter v1 também é fornecido. Essa é uma medida melhor de como o modelo funcionaria em um app Android. Os números da ferramenta de comparativo de mercado ainda vão ser um pouco diferentes de quando a inferência é executada com o modelo no app real.

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

Baixar ou criar o app

Faça o download dos apps de comparativo de mercado do Android pré-criados noturnos usando os links a seguir:

• android_aarch64
• android_arm

Para apps de comparativo de mercado do Android que oferecem suporte a operações do TF via delegado flexível, use os links abaixo:

• android_aarch64
• android_arm

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

Preparar comparativo de mercado

Antes de executar o app de comparativo, instale o app 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 comparativo de mercado

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 comparativo.

• num_threads: int (padrão=1)
  O número de linhas de execução a serem usadas para executar o interpretador do TFLite.
• use_gpu: bool (padrão=false)
  Use o delegado de GPU.
• use_xnnpack: bool (padrão=false)
  Use delegado XNNPACK.

Dependendo do dispositivo que você está usando, algumas dessas opções podem não estar disponíveis ou não ter efeito. Consulte parâmetros para mais parâmetros de performance que podem ser executados com o app de comparativo.

Confira 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

App de comparativo para iOS

Para executar comparativos de mercado em um dispositivo iOS, é necessário criar o app com base na fonte. Coloque o arquivo do modelo LiteRT no diretório benchmark_data da árvore de origem e modifique o arquivo benchmark_params.json. Esses arquivos são empacotados no app, e ele lê os dados do diretório. Acesse o app de comparativo de mercado do iOS para instruções detalhadas.

Comparativos de mercado sobre performance para modelos conhecidos

Esta seção lista comparativos de performance do LiteRT ao executar 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 com o binário de comparativo de mercado nativo.

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

Ele pressupõe que os modelos foram baixados e descompactados no diretório /data/local/tmp/tflite_models. O binário de comparativo de mercado é criado usando estas instruções e presumido estar no diretório /data/local/tmp.

Para executar o comparativo de mercado:

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 de GPU, defina --use_gpu=true.

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

Comparativos de mercado de performance do iOS

Esses números de comparativo de mercado de desempenho foram gerados com o app de comparativo de mercado do iOS.

Para executar comparativos de iOS, o app de comparativo foi modificado para incluir o modelo adequado, e benchmark_params.json foi modificado para definir num_threads como 2. Para usar o delegado de GPU, as opções "use_gpu" : "1" e "gpu_wait_type" : "aggressive" também foram adicionadas a benchmark_params.json.

Trace LiteRT internals

Rastrear elementos internos do LiteRT no Android

Eventos internos do interpretador LiteRT de um app Android podem ser capturados por ferramentas de rastreamento do Android. São os mesmos eventos da API Trace do Android. Portanto, os eventos capturados do código Java/Kotlin são vistos junto com os eventos internos do LiteRT.

Alguns exemplos de eventos:

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

Entre as diferentes opções de captura de rastros, este guia aborda o criador de perfil de CPU do Android Studio e o app Rastreamento do sistema. Consulte a ferramenta de linha de comando Perfetto ou a ferramenta de linha de comando Systrace para outras opções.

Como adicionar eventos de rastreamento no código Java

Este é um snippet de código do app de exemplo Classificação de imagens. O intérprete do LiteRT é executado na seção recognizeImage/runInference. Essa etapa é opcional, mas é útil para ajudar a notar 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 o rastreamento do LiteRT

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

adb shell setprop debug.tflite.trace 1

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

Depois de capturar todos os rastreamentos, desative-os definindo o valor da propriedade como 0.

adb shell setprop debug.tflite.trace 0

CPU Profiler do Android Studio

Capture rastreamentos com o criador de perfil de CPU do Android Studio seguindo as etapas abaixo:

1. Selecione Executar > Criar perfil do "app" nos menus da parte de cima.

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 o botão "Gravar".

5. Pressione o botão "Parar".

6. Investigue o resultado do rastreamento.

   

Neste exemplo, é possível conferir a hierarquia de eventos em uma linha de execução e as estatísticas de cada tempo de operador, além do fluxo de dados de todo o app entre linhas de execução.

App Rastreamento do sistema

Capture rastros sem o Android Studio seguindo as etapas detalhadas no app System Tracing.

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

Rastrear elementos internos do LiteRT no iOS

Os eventos internos do interpretador LiteRT de um app iOS podem ser capturados pela ferramenta Instruments incluída no Xcode. Eles são os eventos de signpost do iOS, então os eventos capturados do código Swift/Objective-C são vistos junto com os eventos internos do LiteRT.

Alguns exemplos de eventos:

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

Ativar o rastreamento do LiteRT

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

1. Selecione Product > Scheme > Edit Scheme… nos menus da parte de cima do Xcode.

2. Clique em "Perfil" no painel à esquerda.

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

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

   

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

Instrumentos do Xcode

Para capturar rastreamentos, siga as etapas abaixo:

1. Selecione Produto > Perfil nos menus da parte de cima do Xcode.

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

3. Pressione o botão "Iniciar".

4. Pressione o botão "Parar".

5. Clique em "os_signpost" para abrir os itens do subsistema de geração de registros do SO.

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

7. Investigue o resultado do rastreamento.

   

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

Como usar os dados de rastreamento

Com os dados de rastreamento, é possível identificar gargalos de desempenho.

Confira 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 threads de inferência, o overhead de programação da CPU poderá levar a uma performance abaixo do ideal. É possível reagendar outras tarefas com uso intenso da CPU no aplicativo para evitar a sobreposição com a inferência do modelo ou ajustar o número de linhas de execução do intérprete.
• 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 compatíveis por outros semelhantes que são aceitos.