Seleziona gli operatori TensorFlow

Poiché la libreria degli operatori incorporata di TensorFlow Lite supporta solo un numero limitato di operatori TensorFlow, non tutti i modelli sono convertibili. Per i dettagli, fare riferimento a Compatibilità con l'operatore .

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

Questo documento illustra come convertire ed eseguire un modello TensorFlow Lite contenente operazioni TensorFlow su una piattaforma di tua scelta. Vengono inoltre discusse le metriche relative a prestazioni e dimensioni e le limitazioni note .

Converti 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 inferenza

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

Android RAA

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

Puoi specificarlo nelle dipendenze build.gradle aggiungendolo insieme allo standard TensorFlow Lite AAR 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'
        }
    }
}

Costruire l'AAR Android

Per ridurre la dimensione binaria o altri casi avanzati, puoi anche creare la libreria manualmente. Presupponendo un ambiente di compilazione TensorFlow Lite funzionante , crea l'AAR Android con le 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 personalizzate e integrate di TensorFlow Lite; e generare il file AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar per TensorFlow ops. Se non disponi di un ambiente di compilazione funzionante, puoi anche creare 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 TensorFlow Lite standard 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

Usando le cialde di cacao

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

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

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

Per le 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 Classificazione immagini per testare la funzione di selezione delle operazioni TF.

• Sostituisci il file 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.

Usando Bazel + Xcode

TensorFlow Lite con TensorFlow ops per iOS può essere creato utilizzando Bazel. Innanzitutto, segui le istruzioni di build 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 sopra il normale TensorFlowLiteC.framework . Si noti che il framework operativo TF selezionato non può essere compilato per l'architettura i386 , quindi è necessario fornire in modo esplicito l'elenco delle architetture di destinazione escludendo i386 .

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

Questo genererà il framework nella bazel-bin/tensorflow/lite/ios/ . Puoi aggiungere questo nuovo framework al tuo progetto Xcode seguendo passaggi simili descritti nella sezione delle impostazioni del progetto Xcode nella guida alla build 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 operativo 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 compilarlo 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 .

Si noti che il TfLiteDelegate necessario 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 delegato.

Pitone

TensorFlow Lite con TensorFlow ops selezionati verrà installato automaticamente con il pacchetto pip TensorFlow . Puoi anche scegliere di installare solo il pacchetto pip dell'interprete TensorFlow Lite .

Metrica

Prestazione

Quando si utilizza una combinazione di operazioni TensorFlow integrate e selezionate, tutte le stesse ottimizzazioni 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 sono una media di 100 esecuzioni. Questi target sono stati creati per Android utilizzando i flag: --config=android_arm64 -c opt .

Dimensione binaria

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

(1) Queste librerie sono create selettivamente per il modello i3d-kinetics-400 con 8 operazioni integrate TFLite e 3 operazioni Tensorflow. Per maggiori dettagli, vedere la sezione Ridurre le dimensioni binarie di TensorFlow Lite .

Limiti noti

• Tipi non supportati: alcune operazioni di TensorFlow potrebbero non supportare l'intero set di tipi di input/output che sono generalmente disponibili in TensorFlow.

Aggiornamenti

• Versione 2.6
  • I supporti per gli operatori basati sugli attributi GraphDef e le inizializzazioni delle risorse HashTable sono migliorati.
• Versione 2.5
  • È possibile applicare un'ottimizzazione nota come quantizzazione post training
• Versione 2.4
  • La compatibilità con i delegati con accelerazione hardware è migliorata