Como a biblioteca de operadores integrada do TensorFlow Lite oferece suporte apenas a um número limitado de operadores do TensorFlow, nem todos os modelos são conversíveis. Para obter detalhes, consulte a compatibilidade do operador .
Para permitir a conversão, os usuários podem habilitar o uso de determinadas operações do TensorFlow em seu modelo TensorFlow Lite. No entanto, a execução de modelos do TensorFlow Lite com operações do TensorFlow requer a extração do tempo de execução principal do TensorFlow, o que aumenta o tamanho binário do interpretador do TensorFlow Lite. Para Android, você pode evitar isso construindo seletivamente apenas as operações necessárias do Tensorflow. Para obter detalhes, consulte reduzir o tamanho do binário .
Este documento descreve como converter e executar um modelo do TensorFlow Lite contendo operações do TensorFlow em uma plataforma de sua escolha. Ele também discute métricas de tamanho e desempenho e limitações conhecidas .
Converter um modelo
O exemplo a seguir mostra como gerar um modelo do TensorFlow Lite com operações selecionadas 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 operações selecionadas do TensorFlow, o cliente também deve usar um tempo de execução do TensorFlow Lite que inclua a biblioteca necessária de operações do TensorFlow.
Android AAR
Para reduzir o tamanho do binário, crie seus próprios arquivos AAR personalizados, conforme orientado na próxima seção . Se o tamanho do binário não for uma preocupação considerável, recomendamos usar o AAR pré-criado com operações do TensorFlow hospedadas no MavenCentral .
Você pode especificar isso em suas dependências build.gradle
adicionando-o ao lado do TensorFlow Lite AAR padrão 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 instantâneos noturnos, certifique-se de ter adicionado o repositório de instantâneos Sonatype .
Depois de adicionar a dependência, o delegado necessário para lidar com as operações do TensorFlow do gráfico deve ser instalado automaticamente para os gráficos que os exigem.
android {
defaultConfig {
ndk {
abiFilters 'armeabi-v7a', 'arm64-v8a'
}
}
}
Construindo o Android AAR
Para reduzir o tamanho do binário ou outros casos avançados, você também pode criar a biblioteca manualmente. Supondo que um ambiente de compilação do TensorFlow Lite esteja funcionando , crie o Android AAR com operações selecionadas do TensorFlow da seguinte maneira:
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 gerará o arquivo AAR bazel-bin/tmp/tensorflow-lite.aar
para operações integradas e personalizadas do TensorFlow Lite; e gere o arquivo AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar
para TensorFlow ops. Se você não tiver um ambiente de construção funcional, também poderá criar os arquivos acima com docker .
A partir daí, você pode importar os arquivos AAR diretamente para seu projeto ou publicar os arquivos AAR personalizados em seu 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
Finalmente, no build.gradle
do seu aplicativo, certifique-se de ter a dependência mavenLocal()
e substitua a dependência padrão do TensorFlow Lite por aquela que tem suporte para operações selecionadas 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
Usando CocoaPods
O TensorFlow Lite fornece CocoaPods de operações de TF selecionados pré-construídos todas as noites para arm64
, dos quais você pode depender juntamente com os CocoaPods TensorFlowLiteSwift
ou TensorFlowLiteObjC
.
# In your Podfile target:
pod 'TensorFlowLiteSwift' # or 'TensorFlowLiteObjC'
pod 'TensorFlowLiteSelectTfOps', '~> 0.0.1-nightly'
Depois de executar pod install
, você precisa fornecer um sinalizador de linker adicional para forçar o carregamento da estrutura de operações do TF selecionada em seu projeto. Em seu projeto Xcode, vá para 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 < 2.9.0:
-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps
Você deve ser capaz de executar quaisquer modelos convertidos com SELECT_TF_OPS
em seu aplicativo iOS. Por exemplo, você pode modificar o aplicativo iOS de classificação de imagens para testar o recurso de operações de TF selecionado.
- Substitua o arquivo de modelo por aquele convertido com
SELECT_TF_OPS
ativado. - Adicione a dependência
TensorFlowLiteSelectTfOps
aoPodfile
conforme instruído. - Adicione o sinalizador de vinculador adicional como acima.
- Execute o aplicativo de exemplo e veja se o modelo funciona corretamente.
Usando Bazel + Xcode
O TensorFlow Lite com operações selecionadas do TensorFlow para iOS pode ser criado usando o Bazel. Primeiro, siga as instruções de compilação do iOS para configurar seu espaço de trabalho Bazel e o arquivo .bazelrc
corretamente.
Depois de configurar o espaço de trabalho com o suporte para iOS ativado, você pode usar o seguinte comando para criar a estrutura de complemento TF ops selecionada, que pode ser adicionada sobre o TensorFlowLiteC.framework
normal. Observe que a estrutura de operações de TF selecionada não pode ser criada para a arquitetura i386
, portanto, você precisa fornecer explicitamente a lista de arquiteturas de destino excluindo i386
.
bazel build -c opt --config=ios --ios_multi_cpus=arm64,x86_64 \
//tensorflow/lite/ios:TensorFlowLiteSelectTfOps_framework
Isso gerará a estrutura no diretório bazel-bin/tensorflow/lite/ios/
. Você pode adicionar essa nova estrutura ao seu projeto Xcode seguindo etapas semelhantes descritas na seção de configurações do projeto Xcode no guia de compilação do iOS.
Depois de adicionar a estrutura ao seu projeto de aplicativo, um sinalizador de vinculador adicional deve ser especificado em seu projeto de aplicativo para forçar o carregamento da estrutura de operações do TF selecionada. Em seu projeto Xcode, vá para Build Settings
-> Other Linker Flags
e adicione:
-force_load <path/to/your/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps>
C/C++
Se você estiver usando Bazel ou CMake para criar o interpretador do TensorFlow Lite, poderá habilitar o delegado Flex vinculando uma biblioteca compartilhada do delegado TensorFlow Lite Flex. Você pode construí-lo com o Bazel como o seguinte comando.
bazel build -c opt --config=monolithic tensorflow/lite/delegates/flex:tensorflowlite_flex
Este comando gera a seguinte biblioteca compartilhada em bazel-bin/tensorflow/lite/delegates/flex
.
Plataforma | Nome da biblioteca |
---|---|
Linux | libtensorflowlite_flex.so |
Mac OS | libtensorflowlite_flex.dylib |
janelas | tensorflowlite_flex.dll |
Observe que o TfLiteDelegate
necessário será instalado automaticamente ao criar o interpretador em tempo de execução, desde que a biblioteca compartilhada esteja vinculada. Não é necessário instalar explicitamente a instância delegada como normalmente é necessário com outros tipos de delegados.
Pitão
O TensorFlow Lite com operações selecionadas do TensorFlow será instalado automaticamente com o pacote pip do TensorFlow . Você também pode optar por instalar apenas o pacote pip do TensorFlow Lite Interpreter .
Métricas
Desempenho
Ao usar uma mistura 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 utilizáveis com o modelo convertido.
A tabela a seguir 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 os sinalizadores: --config=android_arm64 -c opt
.
Construir | Tempo (milissegundos) |
---|---|
Somente operações integradas ( TFLITE_BUILTIN ) | 260,7 |
Usando apenas operações de TF ( SELECT_TF_OPS ) | 264,5 |
tamanho binário
A tabela a seguir descreve o tamanho binário do TensorFlow Lite para cada compilação. Esses destinos foram criados para Android usando --config=android_arm -c opt
.
Construir | Tamanho Binário C++ | Tamanho do APK do Android |
---|---|---|
Somente operações integradas | 796 KB | 561 KB |
Operações integradas + operações de TF | 23,0 MB | 8,0 MB |
Operações integradas + operações de TF (1) | 4,1 MB | 1,8 MB |
(1) Essas bibliotecas são construídas seletivamente para o modelo i3d-kinetics-400 com 8 operações integradas TFLite e 3 operações Tensorflow. Para obter mais detalhes, consulte a seção Reduzir o tamanho binário do TensorFlow Lite .
Limitações conhecidas
- Tipos sem suporte: 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
- Os suportes para operadores baseados em atributos GraphDef e inicializações de recursos HashTable foram aprimorados.
- Versão 2.5
- Você pode aplicar uma otimização conhecida como quantização pós-treinamento
- Versão 2.4
- A compatibilidade com delegados acelerados por hardware melhorou