Selecionar operadores do TensorFlow

Como a biblioteca de operadores integrados do LiteRT só é compatível com um número limitado de operadores do TensorFlow, nem todos os modelos podem ser convertidos. Para mais detalhes, consulte a compatibilidade de operadores.

Para permitir a conversão, os usuários podem ativar o uso de determinadas operações do TensorFlow no modelo LiteRT. No entanto, executar modelos do LiteRT com operações do TensorFlow exige a inclusão do tempo de execução principal do TensorFlow, o que aumenta o tamanho binário do interpretador do LiteRT. No Android, é possível evitar isso criando seletivamente apenas as operações necessárias do TensorFlow. Para mais detalhes, consulte reduzir o tamanho do binário.

Este documento descreve como converter e executar um modelo do LiteRT que contém operações do TensorFlow em uma plataforma de sua escolha. Ele também aborda métricas de desempenho e tamanho e limitações conhecidas.

Converter um modelo

O exemplo a seguir mostra como gerar um modelo do LiteRT 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 LiteRT 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 LiteRT convertido com suporte para operações selecionadas do TensorFlow, o cliente também precisa usar um ambiente de execução do LiteRT 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 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 hospedado no MavenCentral.

É possível especificar isso nas dependências build.gradle adicionando-o ao lado do AAR padrão do LiteRT 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, adicione o repositório de snapshots do Sonatype.

Depois de adicionar a dependência, o delegado necessário para processar as operações do TensorFlow do gráfico será instalado automaticamente para os gráficos que exigem isso.

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 o AAR do Android

Para reduzir o tamanho do binário ou outros casos avançados, também é possível criar a biblioteca manualmente. Supondo um ambiente de criação do LiteRT em funcionamento, crie o AAR do Android com as 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 vai gerar o arquivo AAR bazel-bin/tmp/tensorflow-lite.aar para operações integradas e personalizadas do LiteRT 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 build funcional, também poderá criar os arquivos acima com docker.

De lá, você pode 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 seu app, verifique se você tem a dependência mavenLocal() e substitua a dependência padrão do LiteRT por uma que tenha 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

Usar o CocoaPods

O LiteRT fornece CocoaPods de operações do TensorFlow pré-criadas diariamente para arm64, que você pode usar junto com os CocoaPods TensorFlowLiteSwift ou TensorFlowLiteObjC.

Observação: se você precisar usar operações de seleção do TF em um simulador x86_64, crie a estrutura de operações de seleção por conta própria. Consulte a seção Usar Bazel + Xcode para mais detalhes.

# In your Podfile target:
  pod 'TensorFlowLiteSwift'   # or 'TensorFlowLiteObjC'
  pod 'TensorFlowLiteSelectTfOps', '~> 0.0.1-nightly'

Depois de executar pod install, forneça uma flag de vinculador adicional para forçar o carregamento da estrutura de operações do TF selecionadas no seu 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

Em seguida, você poderá executar qualquer modelo convertido com o SELECT_TF_OPS no app iOS. Por exemplo, é possível modificar o app iOS de classificação de imagens para testar o recurso de operações selecionadas do TF.

• Substitua o arquivo de modelo pelo convertido com SELECT_TF_OPS ativado.
• Adicione a dependência TensorFlowLiteSelectTfOps ao Podfile conforme instruído.
• Adicione a flag do vinculador extra como acima.
• Execute o app de exemplo e verifique se o modelo funciona corretamente.

Como usar o Bazel + Xcode

O LiteRT com operações selecionadas do TensorFlow para iOS pode ser criado usando o Bazel. Primeiro, siga as instruções de build do iOS para configurar corretamente o espaço de trabalho do Bazel e o arquivo .bazelrc.

Depois de configurar o espaço de trabalho com o suporte ao iOS ativado, use o comando a seguir para criar a estrutura de complemento de operações do TF selecionadas, que pode ser adicionada além do TensorFlowLiteC.framework regular. O framework de operações do TensorFlow selecionado não pode ser criado para a arquitetura i386. Portanto, é necessário 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 vai gerar o framework no diretório bazel-bin/tensorflow/lite/ios/. Para adicionar esse novo framework ao seu projeto do Xcode, siga etapas semelhantes às descritas na seção Configurações do projeto do Xcode no guia de build do iOS.

Depois de adicionar o framework ao projeto do app, uma flag de vinculador adicional precisa ser especificada no projeto do app para forçar o carregamento do framework de operações do TF selecionado. No projeto do 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 LiteRT, será possível ativar o delegado flexível vinculando uma biblioteca compartilhada do delegado flexível do LiteRT. É possível criar com o Bazel usando o seguinte comando.

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.

O TfLiteDelegate necessário será instalado automaticamente ao criar o interpretador no tempo de execução, desde que a biblioteca compartilhada esteja vinculada. Não é necessário instalar explicitamente a instância delegada, como normalmente é exigido com outros tipos de delegação.

Observação:esse recurso está disponível desde a versão 2.7.

Python

O LiteRT com operações selecionadas do TensorFlow será instalado automaticamente com o pacote PIP do TensorFlow. Você também pode instalar apenas o pacote pip do interpretador LiteRT.

Métricas

Desempenho

Ao usar uma combinação de operações integradas e selecionadas do TensorFlow, todas as otimizações do LiteRT e as operações integradas otimizadas estarão disponíveis e poderão ser usadas com o modelo convertido.

A tabela a seguir descreve o tempo médio gasto para executar a inferência na MobileNet em um Pixel 2. Os tempos listados são uma média de 100 execuções. Essas metas foram criadas para Android usando as flags: --config=android_arm64 -c opt.

Tamanho do binário

A tabela a seguir descreve o tamanho do binário do LiteRT para cada build. Essas metas foram criadas para Android usando --config=android_arm -c opt.

(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 LiteRT.

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 para operadores baseados em atributos GraphDef e inicializações de recursos HashTable foi aprimorado.
• 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 foi melhorada