Poiché la libreria di operatori integrata TensorFlow Lite supporta solo un numero limitato di operatori TensorFlow, non tutti i modelli sono convertibili. Per maggiori dettagli, consulta la compatibilità degli operatori.
Per consentire la conversione, gli utenti possono attivare l'utilizzo di alcune operazioni TensorFlow nel modello TensorFlow Lite. Tuttavia, l'esecuzione di modelli TensorFlow Lite con le operazioni TensorFlow richiede il pull del runtime principale di TensorFlow, che aumenta la dimensione del file binario dell'interprete di TensorFlow Lite. Per Android, puoi evitare che ciò accada creando selettivamente solo le operazioni TensorFlow richieste. Per maggiori dettagli, consulta la sezione su come ridurre le dimensioni binarie.
Questo documento illustra come convertire ed run un modello TensorFlow Lite contenente le operazioni TensorFlow su una piattaforma a tua scelta. Inoltre, illustra le metriche relative alle prestazioni e alle 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)
Inferenza corsa
Se viene utilizzato un modello TensorFlow Lite convertito con il supporto per operazioni TensorFlow selezionate, il client deve utilizzare anche un runtime TensorFlow Lite che includa la libreria necessaria di operazioni TensorFlow.
AAR Android
Per ridurre le dimensioni del file binario, crea i tuoi file AAR personalizzati come indicato nella sezione successiva. Se le dimensioni binarie non sono un problema considerevole, ti consigliamo di utilizzare il file AAR predefinito con operazioni TensorFlow ospitate su MavenCentral.
Puoi specificare questa opzione nelle dipendenze build.gradle
aggiungendola insieme al file AAR di 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 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 le richiedono.
Nota: la dipendenza delle operazioni TensorFlow è relativamente grande, quindi probabilmente
ti consigliamo di filtrare le ABI x86 non necessarie nel file .gradle
configurando
abiFilters
.
android {
defaultConfig {
ndk {
abiFilters 'armeabi-v7a', 'arm64-v8a'
}
}
}
Creazione dell'AAR di Android
Per ridurre le dimensioni del file binario o altri casi avanzati, puoi anche creare la libreria manualmente. Presupponendo un ambiente di creazione 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
Verrà generato il file AAR bazel-bin/tmp/tensorflow-lite.aar
per le operazioni integrate e personalizzate di TensorFlow e verrà generato il file AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar
per le operazioni TensorFlow. Se
non hai un ambiente di build funzionante, puoi anche creare file precedenti con
docker.
Da qui, 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, nell'elemento build.gradle
dell'app, assicurati di avere la dipendenza mavenLocal()
e sostituisci la dipendenza standard TensorFlow Lite con quella che
supporta 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
Utilizzo di CocoaPods
TensorFlow Lite offre CocoaPods selezionati di notte per operazioni TF di arm64
,
da cui puoi dipendere insieme a TensorFlowLiteSwift
o
TensorFlowLiteObjC
CocoaPods.
Nota: se devi utilizzare operazioni TF selezionate in un simulatore x86_64
, puoi creare
il framework operazioni di selezione autonomamente. Per ulteriori dettagli, consulta la sezione Utilizzo di Bazel + Xcode.
# In your Podfile target:
pod 'TensorFlowLiteSwift' # or 'TensorFlowLiteObjC'
pod 'TensorFlowLiteSelectTfOps', '~> 0.0.1-nightly'
Dopo aver eseguito pod install
, devi fornire un flag di linker aggiuntivo per
forzare il caricamento del framework operazioni TF selezionato nel progetto. Nel progetto Xcode,
vai a 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 precedenti alla 2.9.0:
-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps
A questo punto, dovresti essere in grado di eseguire tutti i modelli convertiti con SELECT_TF_OPS
nell'app per iOS. Ad esempio, puoi modificare l'app per iOS Classificazione delle immagini per testare la funzionalità TF Ops selezionata.
- Sostituisci il file del modello con quello convertito con
SELECT_TF_OPS
attivato. - Aggiungi la dipendenza
TensorFlowLiteSelectTfOps
aPodfile
come indicato. - Aggiungi un ulteriore flag del linker come indicato sopra.
- Esegui l'app di esempio e controlla se il modello funziona correttamente.
Utilizzo di Bazel + Xcode
TensorFlow Lite con operazioni TensorFlow selezionate per iOS può essere creato utilizzando Bazel.
Innanzitutto, segui le istruzioni per lo sviluppo 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 seguente comando per creare il framework del componente aggiuntivo delle operazioni TF selezionato, che può essere aggiunto al normale TensorFlowLiteC.framework
. Tieni presente che il framework delle operazioni TF selezionato non può essere creato per l'architettura i386
, quindi devi fornire esplicitamente l'elenco delle architetture di destinazione che esclude i386
.
bazel build -c opt --config=ios --ios_multi_cpus=arm64,x86_64 \
//tensorflow/lite/ios:TensorFlowLiteSelectTfOps_framework
Il framework verrà generato nella directory bazel-bin/tensorflow/lite/ios/
. Puoi aggiungere questo nuovo framework al progetto Xcode seguendo
i passaggi simili descritti nella sezione Impostazioni progetto Xcode della
Guida allo sviluppo per iOS.
Dopo aver aggiunto il framework al progetto dell'app, devi specificare un flag di linker aggiuntivo nel progetto dell'app per forzare il caricamento del framework delle operazioni di TF selezionato. Nel tuo progetto Xcode, vai a Build Settings
-> Other Linker
Flags
e aggiungi:
-force_load <path/to/your/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps>
C/C++
Se utilizzi Bazel o CMake per creare un interprete di TensorFlow Lite, puoi abilitare il delegato Flex collegando una libreria condivisa di delegato TensorFlow Lite Flex. Puoi crearlo con Bazel come comando seguente.
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 biblioteca |
---|---|
Linux | libtensorflowlite_flex.so |
macOS | libtensorflowlite_flex.dylib |
Windows | tensorflowlite_flex.dll |
Tieni presente che il TfLiteDelegate
necessario verrà installato automaticamente durante la creazione dell'interprete in fase di runtime, purché la libreria condivisa sia collegata. Non è necessario installare esplicitamente l'istanza delegato, come in genere richiesto con altri tipi di delegati.
Nota:questa funzionalità è disponibile dalla versione 2.7.
Python
TensorFlow Lite con operazioni TensorFlow selezionate verrà installato automaticamente con il pacchetto pip TensorFlow. Puoi anche scegliere di installare solo il pacchetto pip TensorFlow Lite Interpreter.
Metriche
Rendimento
Se utilizzi una combinazione di operazioni TensorFlow integrate e selezionate, tutte le ottimizzazioni TensorFlow e le operazioni integrate ottimizzate saranno disponibili e utilizzabili con il modello convertito.
La seguente tabella descrive il tempo medio necessario per eseguire l'inferenza su
MobileNet su Pixel 2. I tempi elencati corrispondono in media a 100 corse. Questi
target sono stati creati per Android utilizzando i flag: --config=android_arm64 -c opt
.
Creare | Tempo (millisecondi) |
---|---|
Solo operazioni integrate (TFLITE_BUILTIN ) |
260,7 |
Utilizzo solo di operazioni TF (SELECT_TF_OPS ) |
264,5 |
Dimensioni binarie
La tabella seguente descrive le dimensioni binarie di TensorFlow Lite per ogni build.
Questi target sono stati creati per Android utilizzando --config=android_arm -c opt
.
Creare | Dimensioni binarie C++ | Dimensioni APK Android |
---|---|---|
Solo operazioni integrate | 796 kB | 561 kB |
Operazioni integrate + operazioni TF | 23 MB | 8,0 MB |
Operazioni integrate + operazioni TF (1) | 4,1 MB | 1,8 MB |
(1) Queste librerie sono create selettivamente per il modello i3d-kinetics-400 con 8 operazioni TFLite integrate e 3 operazioni TensorFlow. Per maggiori dettagli, consulta la sezione Ridurre le dimensioni binarie di TensorFlow Lite.
Limitazioni note
- Tipi non supportati: alcune operazioni TensorFlow potrebbero non supportare l'insieme completo di tipi di input/output in genere disponibili in TensorFlow.
Aggiornamenti
- Versione 2.6
- Il supporto per gli operatori basati su attributi GraphDef e l'inizializzazione delle risorse HashTable sono migliorati.
- Versione 2.5
- Puoi applicare un'ottimizzazione nota come quantizzazione post-addestramento.
- Versione 2.4
- La compatibilità con i delegati con accelerazione hardware è stata migliorata