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:
Em relação a apps Android de comparação compatíveis com o TF ops usando o delegado flexível, acesse os links abaixo:
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:
Quanto aos binários pré-criados noturnos com suporte a TF ops usando o delegado flexível, acesse os links abaixo:
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:
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.
Nome do modelo | Dispositivo | CPU, 4 linhas de execução | GPU |
---|---|---|---|
Mobilenet_1.0_224(float) | Pixel 3 | 23,9 ms | 6,45 ms |
Pixel 4 | 14 ms | 9 ms | |
Mobilenet_1.0_224 (quant) | Pixel 3 | 13,4 ms | --- |
Pixel 4 | 5 ms | --- | |
NASNet para dispositivos móveis | Pixel 3 | 56 ms | --- |
Pixel 4 | 34,5 ms | --- | |
SqueezeNet | Pixel 3 | 35,8 ms | 9,5 ms |
Pixel 4 | 23,9 ms | 11,1 ms | |
Inception_ResNet_V2 | Pixel 3 | 422 ms | 99,8 ms |
Pixel 4 | 272,6 ms | 87,2 ms | |
Inception_V4 | Pixel 3 | 486 ms | 93 ms |
Pixel 4 | 324,1 ms | 97,6 ms |
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
.
Nome do modelo | Dispositivo | CPU, 2 linhas de execução | GPU |
---|---|---|---|
Mobilenet_1.0_224(float) | iPhone XS | 14,8 ms | 3,4 ms |
Mobilenet_1.0_224 (quant) | iPhone XS | 11 ms | --- |
NASNet para dispositivos móveis | iPhone XS | 30,4 ms | --- |
SqueezeNet | iPhone XS | 21,1 ms | 15,5 ms |
Inception_ResNet_V2 | iPhone XS | 261,1 ms | 45,7 ms |
Inception_V4 | iPhone XS | 309 ms | 54,4 ms |
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:
Selecione Executar > Perfil "app" nos menus superiores.
Clique em qualquer lugar da linha do tempo da CPU quando a janela do Profiler aparecer.
Selecione "Rastrear chamadas do sistema" entre os modos de criação de perfil da CPU.
Pressione "Gravar" .
Pressione "Parar" .
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:
Selecione Produto > Esquema > Edit Scheme... nos menus superiores do Xcode.
Clique em "Perfil". no painel esquerdo.
Desmarque a opção "Usar os argumentos e as variáveis de ambiente da ação Executar" caixa de seleção.
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:
Selecione Produto > Profile nos menus superiores do Xcode.
Clique em Logging entre os modelos de criação de perfil quando a ferramenta Instruments for iniciada.
Pressione "Iniciar" .
Pressione "Parar" .
Clique em "os_signpost" para expandir os itens do subsistema do registro do SO.
Clique em "org.tensorflow.lite" subsistema de geração de registros do SO.
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.