Participe do Simpósio Women in ML em 7 de dezembro Inscreva-se agora

Selecionar operadores do TensorFlow

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Como a biblioteca de operadores integrada do TensorFlow Lite é compatível apenas com um número limitado de operadores do TensorFlow, nem todos os modelos são conversíveis. Para obter detalhes, consulte compatibilidade do operador .

Para permitir a conversão, os usuários podem ativar 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 runtime principal do TensorFlow, o que aumenta o tamanho binário do interpretador do TensorFlow Lite. Para Android, você pode evitar isso criando seletivamente apenas as operações necessárias do Tensorflow. Para obter detalhes, consulte reduzir o tamanho 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 desempenho e tamanho 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 TensorFlow selecionadas, o cliente também deve usar um runtime 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 guiado 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 nas dependências do build.gradle adicionando-o ao 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 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 as exigem.

android {
    defaultConfig {
        ndk {
            abiFilters 'armeabi-v7a', 'arm64-v8a'
        }
    }
}

Construindo o AAR do Android

Para reduzir o tamanho binário ou outros casos avançados, você também pode construir a biblioteca manualmente. Supondo um ambiente de compilação do TensorFlow Lite funcional , crie o Android AAR com operações do TensorFlow selecionadas 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 operações do TensorFlow. Se você não tiver um ambiente de compilação funcional, também poderá compilar 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

Por fim, no build.gradle do seu aplicativo, verifique se você tem a dependência mavenLocal() e substitua a dependência padrão do TensorFlow Lite por aquela que tem suporte para determinadas 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

Usando CocoaPods

O TensorFlow Lite fornece CocoaPods de operações TF pré-construídas todas as noites para arm64 , dos quais você pode confiar junto com os 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 vinculador 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 poder executar qualquer modelo convertido com o SELECT_TF_OPS em seu aplicativo iOS. Por exemplo, você pode modificar o aplicativo para iOS de classificação de imagem para testar o recurso de operações de TF selecionado.

  • Substitua o arquivo de modelo pelo convertido com SELECT_TF_OPS habilitado.
  • Adicione a dependência do TensorFlowLiteSelectTfOps ao Podfile conforme as instruções.
  • Adicione o sinalizador de vinculador adicional conforme 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 workspace com o suporte a iOS habilitado, você pode usar o comando a seguir para criar a estrutura de complemento de operações do TF selecionada, que pode ser adicionada ao 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 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 em 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 o Bazel ou o CMake para criar o interpretador do TensorFlow Lite, poderá habilitar o delegado do Flex vinculando uma biblioteca compartilhada do delegado do TensorFlow Lite Flex. Você pode construí-lo com o Bazel com o comando a seguir.

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 de delegado, como normalmente é necessário com outros tipos de delegado.

Pitão

O TensorFlow Lite com operações selecionadas do TensorFlow será instalado automaticamente com o pacote de pip do TensorFlow . Você também pode optar por instalar apenas o pacote pip do TensorFlow Lite Interpreter .

Métricas

atuação

Ao usar uma combinação de operações internas e selecionadas do TensorFlow, todas as mesmas otimizações do TensorFlow Lite e operações internas otimizadas estarão disponíveis e poderão ser usadas 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 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 Android
Apenas operações integradas 796 KB 561 KB
Operações integradas + operações TF 23,0 MB 8,0 MB
Operações integradas + operações 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 TFLite integradas 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 oferecer suporte ao conjunto completo de tipos de entrada/saída que normalmente estão 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
  • Versão 2.4
    • A compatibilidade com delegados acelerados por hardware melhorou