Scopri di più sui nostri annunci di Google AI Edge da I/O

Questa pagina è stata tradotta dall'API Cloud Translation.

Seleziona operatori TensorFlow

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 a Podfile 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