Seleziona gli operatori TensorFlow

Poiché la libreria di operatori integrata di TensorFlow Lite supporta solo un numero limitato di operatori TensorFlow, non tutti i modelli sono convertibili. Per i dettagli, fare riferimento alla compatibilità degli operatori .

Per consentire la conversione, gli utenti possono abilitare l'utilizzo di determinate operazioni TensorFlow nel proprio modello TensorFlow Lite. Tuttavia, l'esecuzione di modelli TensorFlow Lite con operazioni TensorFlow richiede l'inserimento del runtime TensorFlow principale, che aumenta la dimensione binaria dell'interprete TensorFlow Lite. Per Android, puoi evitare questo problema creando selettivamente solo le operazioni Tensorflow richieste. Per i dettagli, fare riferimento a ridurre la dimensione binaria .

Questo documento descrive come convertire ed eseguire un modello TensorFlow Lite contenente operazioni TensorFlow su una piattaforma di tua scelta. Vengono inoltre discussi i parametri relativi alle prestazioni e alle dimensioni e le limitazioni note .

Convertire un modello

L'esempio seguente mostra come generare un modello TensorFlow Lite con operazioni TensorFlow selezionate.

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)

Esegui l'inferenza

Quando si utilizza un modello TensorFlow Lite che è stato convertito con il supporto per determinate operazioni TensorFlow, il client deve utilizzare anche un runtime TensorFlow Lite che includa la libreria necessaria di operazioni TensorFlow.

AndroidAAR

Per ridurre la dimensione binaria, crea i tuoi file AAR personalizzati come guidato nella sezione successiva . Se la dimensione binaria non è un problema considerevole, ti consigliamo di utilizzare l' AAR predefinito con le operazioni TensorFlow ospitate su MavenCentral .

Puoi specificarlo nelle dipendenze build.gradle aggiungendolo insieme all'AAR TensorFlow Lite standard come segue:

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'
}

Per utilizzare gli snapshot notturni, assicurati di aver aggiunto il repository di snapshot Sonatype .

Dopo aver aggiunto la dipendenza, il delegato necessario per la gestione delle operazioni TensorFlow del grafico dovrebbe essere installato automaticamente per i grafici che li richiedono.

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

Creazione dell'AAR Android

Per ridurre la dimensione del binario o altri casi avanzati, puoi anche creare la libreria manualmente. Supponendo un ambiente di compilazione TensorFlow Lite funzionante , crea l'AAR Android con operazioni TensorFlow selezionate come segue:

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

Questo genererà il file AAR bazel-bin/tmp/tensorflow-lite.aar per le operazioni integrate e personalizzate di TensorFlow Lite; e generare il file AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar per le operazioni TensorFlow. Se non disponi di un ambiente di compilazione funzionante, puoi anche creare i file sopra con docker .

Da lì, puoi importare i file AAR direttamente nel tuo progetto o pubblicare i file AAR personalizzati nel tuo repository Maven locale:

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

Infine, nel build.gradle della tua app, assicurati di avere la dipendenza mavenLocal() e sostituisci la dipendenza standard di TensorFlow Lite con quella che supporta le operazioni TensorFlow selezionate:

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

Utilizzando CocoaPods

TensorFlow Lite fornisce CocoaPods precostruiti notturni per TF ops per arm64 , su cui puoi fare affidamento insieme ai CocoaPods TensorFlowLiteSwift o TensorFlowLiteObjC .

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

Dopo aver eseguito pod install , devi fornire un flag del linker aggiuntivo per forzare il caricamento del framework TF ops selezionato nel tuo progetto. Nel tuo progetto Xcode, vai su Build Settings -> Other Linker Flags e aggiungi:

Per versioni >= 2.9.0:

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.xcframework/ios-arm64/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

Per le versioni < 2.9.0:

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

Dovresti quindi essere in grado di eseguire qualsiasi modello convertito con SELECT_TF_OPS nella tua app iOS. Ad esempio, puoi modificare l' app iOS di classificazione delle immagini per testare la funzionalità delle operazioni TF selezionate.

  • Sostituisci il file del modello con quello convertito con SELECT_TF_OPS abilitato.
  • Aggiungi la dipendenza TensorFlowLiteSelectTfOps al Podfile come indicato.
  • Aggiungi il flag del linker aggiuntivo come sopra.
  • Esegui l'app di esempio e verifica se il modello funziona correttamente.

Utilizzando Bazel + Xcode

TensorFlow Lite con operazioni TensorFlow selezionate per iOS può essere creato utilizzando Bazel. Innanzitutto, segui le istruzioni di creazione di iOS per configurare correttamente l'area di lavoro Bazel e il file .bazelrc .

Dopo aver configurato l'area di lavoro con il supporto iOS abilitato, puoi utilizzare il comando seguente per creare il framework aggiuntivo TF ops selezionato, che può essere aggiunto al normale TensorFlowLiteC.framework . Tieni presente che il framework TF ops selezionato non può essere creato per l'architettura i386 , quindi devi fornire esplicitamente l'elenco delle architetture di destinazione escluso i386 .

bazel build -c opt --config=ios --ios_multi_cpus=arm64,x86_64 \
  //tensorflow/lite/ios:TensorFlowLiteSelectTfOps_framework

Questo genererà il framework nella directory bazel-bin/tensorflow/lite/ios/ . Puoi aggiungere questo nuovo framework al tuo progetto Xcode seguendo passaggi simili descritti nella sezione Impostazioni del progetto Xcode nella guida allo sviluppo di iOS.

Dopo aver aggiunto il framework al progetto dell'app, è necessario specificare un flag del linker aggiuntivo nel progetto dell'app per forzare il caricamento del framework delle operazioni TF selezionato. Nel tuo progetto Xcode, vai su Build Settings -> Other Linker Flags e aggiungi:

-force_load <path/to/your/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps>

C/C++

Se utilizzi Bazel o CMake per creare l'interprete TensorFlow Lite, puoi abilitare il delegato Flex collegando una libreria condivisa del delegato TensorFlow Lite Flex. Puoi costruirlo con Bazel come il seguente comando.

bazel build -c opt --config=monolithic tensorflow/lite/delegates/flex:tensorflowlite_flex

Questo comando genera la seguente libreria condivisa in bazel-bin/tensorflow/lite/delegates/flex .

piattaforma Nome della libreria
Linux libtensorflowlite_flex.so
Mac OS libtensorflowlite_flex.dylib
finestre tensorflowlite_flex.dll

Tieni presente che il necessario TfLiteDelegate verrà installato automaticamente durante la creazione dell'interprete in fase di esecuzione purché la libreria condivisa sia collegata. Non è necessario installare in modo esplicito l'istanza del delegato come in genere richiesto con altri tipi di delegati.

Pitone

TensorFlow Lite con le operazioni TensorFlow selezionate verrà installato automaticamente con il pacchetto pip TensorFlow . Puoi anche scegliere di installare solo il pacchetto pip di TensorFlow Lite Interpreter .

Metrica

Prestazione

Quando si utilizza una combinazione di operazioni integrate e selezionate di TensorFlow, tutte le stesse ottimizzazioni di TensorFlow Lite e operazioni integrate ottimizzate saranno disponibili e utilizzabili con il modello convertito.

La tabella seguente descrive il tempo medio impiegato per eseguire l'inferenza su MobileNet su un Pixel 2. I tempi elencati rappresentano una media di 100 esecuzioni. Questi target sono stati creati per Android utilizzando i flag: --config=android_arm64 -c opt .

Costruire Tempo (millisecondi)
Solo operazioni integrate ( TFLITE_BUILTIN ) 260,7
Utilizzando solo le operazioni TF ( SELECT_TF_OPS ) 264,5

Dimensione binaria

La tabella seguente descrive la dimensione binaria di TensorFlow Lite per ciascuna build. Questi target sono stati creati per Android utilizzando --config=android_arm -c opt .

Costruire Dimensione binaria C++ Dimensioni dell'APK Android
Solo operazioni integrate 796KB 561KB
Operazioni integrate + operazioni TF 23,0 MB 8,0MB
Operazioni integrate + operazioni TF (1) 4,1MB 1,8MB

(1) Queste librerie sono create selettivamente per il modello i3d-cinetica-400 con 8 operazioni integrate TFLite e 3 operazioni Tensorflow. Per maggiori dettagli, consulta la sezione Riduci le dimensioni del binario di TensorFlow Lite .

Limitazioni note

  • Tipi non supportati: alcune operazioni di TensorFlow potrebbero non supportare il set completo di tipi di input/output generalmente disponibili in TensorFlow.

Aggiornamenti

  • Versione 2.6
    • Il supporto per gli operatori basati sugli attributi GraphDef e le inizializzazioni delle risorse HashTable è stato migliorato.
  • Versione 2.5
  • Versione 2.4
    • La compatibilità con i delegati con accelerazione hardware è migliorata