Seleziona operatori TensorFlow

Poiché la libreria di operatori integrati LiteRT supporta solo un numero limitato di operatori TensorFlow, non tutti i modelli sono convertibili. Per maggiori dettagli, consulta la compatibilità con gli operatori.

Per consentire la conversione, gli utenti possono attivare l'utilizzo di determinate operazioni TensorFlow nel proprio modello LiteRT. Tuttavia, l'esecuzione di modelli LiteRT con operazioni TensorFlow richiede l'estrazione del runtime TensorFlow di base, il che aumenta le dimensioni del file binario dell'interprete LiteRT. Per Android, puoi evitare questo problema creando selettivamente solo le operazioni TensorFlow richieste. Per i dettagli, consulta Ridurre le dimensioni del binario.

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

Convertire un modello

L'esempio seguente mostra come generare un modello LiteRT 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 LiteRT 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 LiteRT convertito con il supporto di operazioni TensorFlow selezionate, il client deve utilizzare anche un runtime LiteRT che includa la libreria necessaria di operazioni TensorFlow.

Android AAR

Per ridurre le dimensioni del file binario, crea i tuoi file AAR personalizzati come indicato nella sezione successiva. Se le dimensioni del binario non sono 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 all'AAR LiteRT standard nel seguente modo:

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.

Una volta aggiunta la dipendenza, il delegato necessario per la gestione delle operazioni TensorFlow del grafico dovrebbe essere installato automaticamente per i grafici che lo richiedono.

Nota: la dipendenza dalle operazioni TensorFlow è relativamente grande, quindi probabilmente vorrai filtrare le ABI x86 non necessarie nel file .gradle configurando abiFilters.

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

Creazione dell'AAR Android

Per ridurre le dimensioni del binario o per altri casi avanzati, puoi anche creare la libreria manualmente. Supponendo un ambiente di compilazione LiteRT funzionante, compila l'AAR Android con le operazioni TensorFlow selezionate nel seguente modo:

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 LiteRT e il file AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar per le operazioni TensorFlow. Se non hai un ambiente di compilazione funzionante, puoi anche compilare i file sopra indicati con Docker.

Da qui, puoi importare i file AAR direttamente nel tuo progetto oppure 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 dell'app, assicurati di avere la dipendenza mavenLocal() e sostituisci la dipendenza LiteRT standard 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

LiteRT fornisce CocoaPods con operazioni TF selezionate precompilate ogni notte per arm64, su cui puoi fare affidamento insieme a CocoaPods TensorFlowLiteSwift o TensorFlowLiteObjC.

Nota: se devi utilizzare determinate operazioni TF in un simulatore x86_64, puoi creare il framework delle operazioni selezionate. 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 del linker aggiuntivo per forzare il caricamento del framework delle operazioni TF selezionate nel tuo 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

Dovresti quindi essere in grado di eseguire tutti i modelli convertiti con SELECT_TF_OPS nella tua app per iOS. Ad esempio, puoi modificare l'app per iOS di classificazione delle immagini per testare la funzionalità di selezione delle operazioni TF.

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

Utilizzo di Bazel + Xcode

LiteRT con operazioni TensorFlow selezionate per iOS può essere creato utilizzando Bazel. Innanzitutto, segui le istruzioni di compilazione per iOS per configurare correttamente lo spazio di lavoro Bazel e il file .bazelrc.

Dopo aver configurato lo spazio di lavoro con il supporto iOS attivato, puoi utilizzare il seguente comando per creare il framework del componente aggiuntivo TF ops selezionato, che può essere aggiunto sopra il normale TensorFlowLiteC.framework. Tieni presente che il framework di operazioni TF selezionate non può essere creato per l'architettura i386, quindi devi fornire esplicitamente 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

In questo modo viene generato il framework nella directory bazel-bin/tensorflow/lite/ios/. Puoi aggiungere questo nuovo framework al tuo progetto Xcode seguendo passaggi simili a quelli descritti nella sezione Impostazioni del progetto Xcode della guida alla build per iOS.

Dopo aver aggiunto il framework al progetto dell'app, nel progetto dell'app deve essere specificata un'ulteriore opzione del linker per forzare il caricamento del framework delle operazioni TF selezionate. Nel 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 l'interprete LiteRT, puoi attivare il delegato Flex collegando una libreria condivisa del delegato LiteRT Flex. Puoi crearlo con Bazel con 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.

Tieni presente che TfLiteDelegate necessari verranno installati automaticamente durante la creazione dell'interprete in fase di runtime, a condizione che la libreria condivisa sia collegata. Non è necessario installare esplicitamente l'istanza delegata come richiesto in genere con altri tipi di delegati.

Nota: questa funzionalità è disponibile a partire dalla versione 2.7.

Python

LiteRT con operazioni TensorFlow selezionate verrà installato automaticamente con il pacchetto pip TensorFlow. Puoi anche scegliere di installare solo il pacchetto pip dell'interprete LiteRT.

Metriche

Rendimento

Quando utilizzi un mix di operazioni TensorFlow integrate e selezionate, tutte le ottimizzazioni LiteRT e le 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 Pixel 2. I tempi elencati sono una media di 100 corse. Questi target sono stati creati per Android utilizzando i flag: --config=android_arm64 -c opt.

Dimensioni binarie

La seguente tabella descrive le dimensioni del binario di LiteRT 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 di TFLite e 3 operazioni di TensorFlow. Per maggiori dettagli, consulta la sezione Ridurre le dimensioni del binario LiteRT.

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
  • È stato migliorato il supporto per gli operatori basati su attributi GraphDef e per le inizializzazioni delle risorse HashTable.
• Versione 2.5
  • Puoi applicare un'ottimizzazione nota come quantizzazione post-addestramento.
• Versione 2.4
  • È stata migliorata la compatibilità con i delegati con accelerazione hardware