Como a biblioteca de operadores integrados do TensorFlow Lite aceita apenas um número limitado de operadores do TensorFlow, nem todos os modelos são conversíveis. Para ver detalhes, consulte a compatibilidade do operador (em inglês).
Para permitir a conversão, os usuários podem ativar o uso de determinadas operações do TensorFlow no modelo do TensorFlow Lite. No entanto, para executar modelos do TensorFlow Lite com operações do TensorFlow é necessário extrair o ambiente de execução núcleo do TensorFlow, o que aumenta o tamanho binário do interpretador do TensorFlow Lite. No Android, você pode evitar isso criando seletivamente apenas as operações necessárias do Tensorflow. Para ver mais detalhes, consulte reduzir o tamanho do binário.
Neste documento, descrevemos como converter e run um modelo do TensorFlow Lite que contém operações do TensorFlow em uma plataforma de sua escolha. Ele também discute métricas de desempenho e tamanho e limitações conhecidas.
Converter um modelo
O exemplo a seguir mostra como gerar um modelo do TensorFlow Lite com algumas operações do TensorFlow.
import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.target_spec.supported_ops = [
tf.lite.OpsSet.TFLITE_BUILTINS, # enable TensorFlow Lite ops.
tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.
]
tflite_model = converter.convert()
open("converted_model.tflite", "wb").write(tflite_model)
Executar inferência
Ao usar um modelo do TensorFlow Lite que foi convertido com suporte para algumas operações do TensorFlow, o cliente também precisa usar um ambiente de execução do TensorFlow Lite que inclua a biblioteca necessária de operações do TensorFlow.
AAR do Android
Para reduzir o tamanho do binário, crie seus próprios arquivos AAR personalizados, conforme explicado na próxima seção. Se o tamanho do binário não for uma preocupação considerável, recomendamos usar as AARs pré-criadas com operações do TensorFlow hospedadas no MavenCentral.
É possível especificar isso nas dependências de build.gradle
adicionando-o com
o AAR padrão do TensorFlow Lite da seguinte maneira:
dependencies {
implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
// This dependency adds the necessary TF op support.
implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.0.0-nightly-SNAPSHOT'
}
Para usar snapshots noturnos, verifique se você adicionou o repositório de snapshots Sonatype.
Depois de adicionar a dependência, o delegado necessário para lidar com as operações do TensorFlow do gráfico será instalado automaticamente nos gráficos que precisam delas.
Observação: a dependência de operações do TensorFlow é relativamente grande. Portanto, é recomendável
filtrar ABIs x86 desnecessárias no arquivo .gradle
configurando
o abiFilters
.
android {
defaultConfig {
ndk {
abiFilters 'armeabi-v7a', 'arm64-v8a'
}
}
}
Como criar as AARs do Android
Para reduzir o tamanho do binário ou outros casos avançados, você também pode criar a biblioteca manualmente. Supondo um ambiente de build do TensorFlow Lite em funcionamento, crie o AAR do Android com algumas operações do TensorFlow da seguinte forma:
sh tensorflow/lite/tools/build_aar.sh \
--input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
--target_archs=x86,x86_64,arm64-v8a,armeabi-v7a
Isso vai gerar o arquivo AAR bazel-bin/tmp/tensorflow-lite.aar
para
operações integradas e personalizadas do TensorFlow Lite e o arquivo AAR
bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar
para operações do TensorFlow. Se você
não tiver um ambiente de criação funcional, também poderá criar os arquivos acima com o
docker.
Depois disso, é possível importar os arquivos AAR diretamente para o projeto ou publicar os arquivos AAR personalizados no repositório Maven local:
mvn install:install-file \
-Dfile=bazel-bin/tmp/tensorflow-lite.aar \
-DgroupId=org.tensorflow \
-DartifactId=tensorflow-lite -Dversion=0.1.100 -Dpackaging=aar
mvn install:install-file \
-Dfile=bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar \
-DgroupId=org.tensorflow \
-DartifactId=tensorflow-lite-select-tf-ops -Dversion=0.1.100 -Dpackaging=aar
Por fim, no build.gradle
do app, verifique se você tem a dependência mavenLocal()
e substitua a dependência padrão do TensorFlow Lite por uma que
ofereça suporte para algumas operações do TensorFlow:
allprojects {
repositories {
mavenCentral()
maven { // Only for snapshot artifacts
name 'ossrh-snapshot'
url 'https://oss.sonatype.org/content/repositories/snapshots'
}
mavenLocal()
}
}
dependencies {
implementation 'org.tensorflow:tensorflow-lite:0.1.100'
implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.1.100'
}
iOS
Como usar o CocoaPods
O TensorFlow Lite oferece acesso noturno e pré-criado do CocoaPods Ops Ops para arm64
,
de que você pode depender com o CocoaPods TensorFlowLiteSwift
ou
TensorFlowLiteObjC
.
Observação: se você precisar usar operações selecionadas do TF em um simulador do x86_64
, poderá criar
o framework de operações de seleção por conta própria. Consulte a seção Como usar o Bazel + Xcode para mais detalhes.
# In your Podfile target:
pod 'TensorFlowLiteSwift' # or 'TensorFlowLiteObjC'
pod 'TensorFlowLiteSelectTfOps', '~> 0.0.1-nightly'
Depois de executar pod install
, você precisa fornecer uma flag extra do vinculador para
forçar o carregamento do framework de operações do TF selecionado no projeto. No seu projeto do Xcode, acesse Build Settings
-> Other Linker Flags
e adicione:
Para versões >= 2.9.0:
-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.xcframework/ios-arm64/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps
Para versões anteriores à 2.9.0:
-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps
Você conseguirá executar todos os modelos convertidos com o SELECT_TF_OPS
no seu app para iOS. Por exemplo, é possível modificar o app iOS de classificação de imagens para testar o recurso TFOps selecionado.
- Substitua o arquivo modelo pelo que foi convertido com
SELECT_TF_OPS
ativado. - Adicione a dependência
TensorFlowLiteSelectTfOps
aoPodfile
conforme instruído. - Adicione a sinalização adicional do vinculador conforme mostrado acima.
- Execute o app de exemplo e verifique se o modelo funciona corretamente.
Como usar o Bazel + Xcode
Use o Bazel para criar o TensorFlow Lite com algumas operações do TensorFlow para iOS.
Primeiro, siga as instruções de build do iOS para configurar o espaço de trabalho do Bazel e o arquivo .bazelrc
corretamente.
Depois de configurar o espaço de trabalho com o suporte para iOS ativado, use o
comando a seguir para criar o framework do complemento TF ops selecionado, que pode ser adicionado
sobre o TensorFlowLiteC.framework
normal. O framework selecionado do TFOps
não pode ser criado para a arquitetura i386
. Portanto, é necessário fornecer explicitamente
a lista de arquiteturas de destino, exceto i386
.
bazel build -c opt --config=ios --ios_multi_cpus=arm64,x86_64 \
//tensorflow/lite/ios:TensorFlowLiteSelectTfOps_framework
Isso vai gerar o framework no diretório
bazel-bin/tensorflow/lite/ios/
. Você pode adicionar esse novo framework ao seu projeto Xcode seguindo as etapas descritas na seção Configurações do projeto do Xcode no guia de criação do iOS.
Depois de adicionar o framework ao projeto do app, uma sinalização extra do vinculador
precisa ser especificada no projeto do app para forçar o carregamento do framework
do TF ops selecionado. No seu projeto Xcode, acesse Build Settings
-> Other Linker
Flags
e adicione:
-force_load <path/to/your/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps>
C/C++
Se você estiver usando o Bazel ou o CMake para criar o interpretador do TensorFlow Lite, será possível ativar o delegado do Flex vinculando uma biblioteca compartilhada delegate do TensorFlow Lite Flex. Você pode criá-lo com o Bazel como no comando a seguir.
bazel build -c opt --config=monolithic tensorflow/lite/delegates/flex:tensorflowlite_flex
Esse comando gera a seguinte biblioteca compartilhada em
bazel-bin/tensorflow/lite/delegates/flex
.
Plataforma | Nome da biblioteca |
---|---|
Linux | libtensorflowlite_flex.so |
macOS | libtensorflowlite_flex.dylib |
Windows | tensorflowlite_flex.dll |
O TfLiteDelegate
necessário será instalado automaticamente na
criação do interpretador durante a execução, desde que a biblioteca compartilhada esteja vinculada. Não é necessário instalar explicitamente a instância do delegado, como normalmente é necessário com outros tipos de delegados.
Observação:este recurso está disponível a partir da versão 2.7.
Python
O TensorFlow Lite com operações selecionadas do TensorFlow será instalado automaticamente com o pacote pip do TensorFlow. Também é possível instalar apenas o pacote pip do TensorFlow Lite Interpreter.
Métricas
Desempenho
Ao usar uma combinação de operações integradas e selecionadas do TensorFlow, todas as mesmas otimizações do TensorFlow Lite e operações integradas otimizadas estarão disponíveis e usáveis com o modelo convertido.
A tabela abaixo descreve o tempo médio necessário para executar a inferência no
MobileNet em um Pixel 2. Os tempos listados são uma média de 100 execuções. Esses
destinos foram criados para Android usando as flags: --config=android_arm64 -c opt
.
Criação | Tempo (milissegundos) |
---|---|
Somente operações integradas (TFLITE_BUILTIN ) |
260,7 |
Usando apenas operações do TF (SELECT_TF_OPS ) |
264,5 |
Tamanho do binário
A tabela a seguir descreve o tamanho binário do TensorFlow Lite para cada build.
Esses destinos foram criados para Android usando --config=android_arm -c opt
.
Criação | Tamanho do binário C++ | Tamanho do APK do Android |
---|---|---|
Somente operações integradas | 796 KB | 561 KB |
Operações integradas + Operações do TF | 23,0 MB | 8,0 MB |
Operações integradas + Operações do TF (1) | 4,1 MB | 1,8 MB |
(1) Essas bibliotecas são criadas seletivamente para o modelo i3d-kinetics-400 com oito operações integradas do TFLite e três operações do Tensorflow. Para mais detalhes, consulte a seção Reduzir o tamanho do binário do TensorFlow Lite.
Limitações conhecidas
- Tipos não compatíveis: algumas operações do TensorFlow podem não ser compatíveis com o conjunto completo de tipos de entrada/saída normalmente disponíveis no TensorFlow.
Atualizações
- Versão 2.6
- O suporte a operadores baseados em atributos GraphDef e inicializações de recursos HashTable foi aprimorado.
- Versão 2.5
- É possível aplicar uma otimização conhecida como quantização pós-treinamento
- Versão 2.4
- A compatibilidade com delegados acelerados por hardware foi melhorada