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:
Selecione Executar> Perfil 'aplicativo' nos menus superiores.
Clique em qualquer lugar na linha do tempo da CPU quando a janela Profiler aparecer.
Selecione 'Trace System Calls' entre os modos de perfil de CPU.
Pressione o botão 'Gravar'.
Pressione o botão 'Parar'.
Investigue o resultado do rastreamento.
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 .
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:
Selecione Produto > Esquema > Editar Esquema... nos menus superiores do Xcode.
Clique em ‘Perfil’ no painel esquerdo.
Desmarque a caixa de seleção 'Usar os argumentos e variáveis de ambiente da ação Executar'.
Adicione
debug.tflite.trace
na seção 'Variáveis 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:
Selecione Produto > Perfil nos menus superiores do Xcode.
Clique em Log entre modelos de criação de perfil quando a ferramenta Instruments for iniciada.
Pressione o botão 'Iniciar'.
Pressione o botão 'Parar'.
Clique em 'os_signpost' para expandir os itens do subsistema OS Logging.
Clique no subsistema de registro do SO 'org.tensorflow.lite'.
Investigue o resultado do rastreamento.
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.