Selecionar operadores do TensorFlow

Como a biblioteca do operador LiteRT integrado é compatível apenas com de operadores TensorFlow, nem todos os modelos podem ser convertidos. Para mais detalhes, Consulte a compatibilidade do operador.

Para permitir a conversão, os usuários podem ativar o uso de determinadas propriedades do ops no modelo LiteRT. No entanto, executar Os modelos LiteRT com operações do TensorFlow exigem a extração do núcleo ambiente de execução do TensorFlow, que aumenta o tamanho do binário do interpretador do LiteRT. Para Android, você pode evitar isso criando seletivamente apenas o TensorFlow necessário ops. Para mais detalhes, consulte Reduzir binário tamanho.

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

Converter um modelo

O exemplo a seguir mostra como gerar um modelo LiteRT com a função select 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 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 que foi convertido com suporte para selecionar operações do TensorFlow, o cliente também precisará usar um ambiente de execução LiteRT que inclui 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 as orientações a próxima seção. Se o tamanho binário não for um use as AARs com operações do TensorFlow hospedado em MavenCentral.

Para especificar isso nas dependências de build.gradle, adicione-o com a AAR LiteRT padrão da seguinte forma:

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 os snapshots noturnos, confira se você adicionou o snapshot do Sonatype repositório.

Depois de adicionar a dependência, o delegado necessário para lidar com o as operações do TensorFlow do gráfico devem ser instaladas automaticamente para gráficos que exigem para resolvê-los com rapidez.

Observação: a dependência de operações do TensorFlow é relativamente grande, então você provavelmente querer filtrar ABIs x86 desnecessárias no arquivo .gradle configurando seu 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, também é possível criar o biblioteca manualmente. Considerando que uma versão LiteRT funcional ambiente, crie o AAR do Android com algumas operações do TensorFlow como 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 gera o arquivo AAR bazel-bin/tmp/tensorflow-lite.aar para Operações integradas e personalizadas da LiteRT e gerar o arquivo AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar para operações do TensorFlow. Se você não tem um ambiente de criação funcional, você também pode criar acima os arquivos com Docker.

A partir daí, você pode importar os arquivos AAR diretamente para seu projeto ou Publique 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, confira se você tem o mavenLocal(). e substituir a dependência LiteRT padrão pela que oferece suporte a 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

A LiteRT fornece CocoaPods, TF ops CocoaPods, pré-criado todas as noites para arm64, que você pode usar junto com TensorFlowLiteSwift ou TensorFlowLiteObjC CocoaPods.

Observação: se precisar usar determinadas operações do TF em um simulador do x86_64, crie a estrutura de operações de seleção. Consulte 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 TFOps selecionado no projeto. No 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ê conseguirá executar todos os modelos convertidos com o SELECT_TF_OPS no seu app iOS. Por exemplo, é possível modificar a API de classificação de imagens app para testar o recurso de seleção de operações do TF.

• Substitua o arquivo modelo pelo que foi convertido com SELECT_TF_OPS ativado.
• Adicione a dependência TensorFlowLiteSelectTfOps ao Podfile 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

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

Depois de configurar o espaço de trabalho com suporte para iOS ativado, use o o comando a seguir para criar o framework selecionado do complemento TF Ops, que pode ser adicionado em comparação com o TensorFlowLiteC.framework normal. Observe que as operações do TF selecionadas não pode ser criado para a arquitetura i386. Portanto, é preciso explicitamente fornecem 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 em bazel-bin/tensorflow/lite/ios/ diretório. Para adicionar essa nova estrutura ao seu projeto Xcode, siga estas etapas: etapas semelhantes descritas no projeto para o Xcode de configuração no Guia de criação do iOS.

Depois de adicionar a estrutura ao projeto do aplicativo, outro sinalizador do vinculador deve ser especificado no projeto do app para forçar o carregamento das operações selecionadas do TF de análise de dados em nuvem. No seu 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 LiteRT intérprete, é possível ativar o delegado Flex vinculando um LiteRT Flex e delegar biblioteca compartilhada. 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:

O TfLiteDelegate necessário será instalado automaticamente quando criar o interpretador no momento da execução, desde que a biblioteca compartilhada esteja vinculada. Ela não é necessário instalar explicitamente a instância do delegado como normalmente exigido com outros tipos de delegados.

Observação:este recurso está disponível a partir da versão 2.7.

Python

O LiteRT com operações selecionadas do TensorFlow será instalado automaticamente com o pacote pip do TensorFlow; Você pode escolha também instalar apenas o pip liteRT intérprete pacote.

Métricas

Desempenho

Ao usar uma combinação de operações integradas e selecionadas do TensorFlow, todas Otimizações do LiteRT e operações integradas otimizadas estarão disponíveis e utilizável com o modelo convertido.

A tabela a seguir descreve o tempo médio necessário para executar a inferência MobileNet em um Pixel 2. Os tempos listados são uma média de 100 execuções. Esses os destinos foram criados para Android usando as flags: --config=android_arm64 -c opt.

Tamanho do binário

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

(1) Essas bibliotecas são criadas seletivamente para o i3d-kinetics-400 modelo com 8 operações integradas do TFLite e 3 operações do Tensorflow. Para mais detalhes, consulte a Seção Reduzir o tamanho do binário 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 que normalmente estão disponíveis no TensorFlow.

Atualizações

• Versão 2.6
  • Suporte a operadores baseados no atributo GraphDef e recurso HashTable inicializações melhoraram.
• Versão 2.5
  • Você pode aplicar uma otimização conhecida como pós-treinamento quantização
• Versão 2.4
  • A compatibilidade com delegados acelerados por hardware foi melhorada