Seleziona operatori TensorFlow

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

Per consentire la conversione, gli utenti possono attivare l'utilizzo di determinati TensorFlow op nel modello LiteRT. Tuttavia, la pubblicazione I modelli LiteRT con operazioni TensorFlow richiedono il pull del core Runtime TensorFlow, che aumenta le dimensioni binarie dell'interprete LiteRT. Per Android, è possibile evitarlo creando selettivamente solo le risorse TensorFlow richieste operazioni. Per maggiori dettagli, consulta la sezione su come ridurre i file binari dimensioni.

Questo documento illustra come convertire e esegui un modello LiteRT contenente operazioni TensorFlow su una la piattaforma di tua scelta. Inoltre, illustra le prestazioni e le dimensioni metriche e limitazioni note.

Converti un modello

L'esempio seguente mostra come generare un modello LiteRT con select Operazioni di TensorFlow.

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)

Inferenza corsa

Quando utilizzi un modello LiteRT che è stato convertito con il supporto di alcune operazioni TensorFlow, il client deve utilizzare anche un runtime LiteRT che include la libreria operativa di TensorFlow necessaria.

AAR Android

Per ridurre le dimensioni del file binario, crea i tuoi file AAR personalizzati seguendo le istruzioni alla sezione successiva. Se la dimensione binaria non è un problema, ti consigliamo di usare il file AAR predefinito con le operazioni di TensorFlow ospitato presso MavenCentral.

Puoi specificare questo elemento nelle dipendenze build.gradle aggiungendolo insieme l'ARL LiteRT 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 le istantanee notturne, assicurati di aver aggiunto Sonatype snapshot un repository attendibile.

Una volta aggiunta la dipendenza, il delegato necessario per gestire Le operazioni TensorFlow del grafico devono essere installate automaticamente per i grafici che richiedono che li rappresentano.

Nota: la dipendenza delle operazioni TensorFlow è relativamente grande, quindi probabilmente vuoi filtrare le ABI x86 non necessarie nel file .gradle configurando il tuo 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 il modello manualmente. Presupporre una build LiteRT funzionante , crea l'AAR Android utilizzando le operazioni TensorFlow selezionate come che 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 Operazioni LiteRT integrate e personalizzate; e generi il file AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar per le operazioni TensorFlow. Se non disponi di un ambiente di build funzionante, puoi anche creare file precedenti Docker.

Da qui, puoi importare i file AAR direttamente nel tuo progetto oppure pubblica 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 mavenLocal() e sostituisci la dipendenza LiteRT standard con quella che supporta alcune operazioni TensorFlow:

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 offre CocoaPods selezionati di TF di notte per arm64, su cui puoi fare affidamento insieme a TensorFlowLiteSwift TensorFlowLiteObjC CocoaPods.

Nota: se devi utilizzare operazioni TF selezionate in un simulatore x86_64, puoi creare il framework operazioni selezionate. Consulta la sezione Utilizzare Bazel + Xcode per ulteriori dettagli.

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

Dopo aver eseguito pod install, devi fornire un flag linker aggiuntivo per forza il caricamento del framework operazioni TF selezionato nel progetto. Nel tuo 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 < 2.9.0:

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

A questo punto dovresti essere in grado di eseguire qualsiasi modello convertito con SELECT_TF_OPS in la tua app per iOS. Ad esempio, puoi modificare la classificazione delle immagini iOS app per testare la funzionalità operazione di TF 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

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

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

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

Il framework verrà generato in bazel-bin/tensorflow/lite/ios/ . Puoi aggiungere questo nuovo framework al tuo progetto Xcode seguendo passaggi simili a quelli descritti nel progetto Xcode impostazioni nel Guida allo sviluppo per iOS.

Dopo aver aggiunto il framework al progetto dell'app, viene aggiunto un flag linker aggiuntivo Deve essere specificato nel progetto dell'app per forzare il caricamento delle operazioni TF selezionate il modello di machine learning. 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 LiteRT interprete, puoi abilitare il delegato Flex collegando un server LiteRT Flex delega la libreria condivisa. 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.

Tieni presente che TfLiteDelegate necessaria verrà installata automaticamente quando creando l'interprete in fase di runtime, purché la libreria condivisa sia collegata. it non è necessario installare esplicitamente l'istanza delegata, come avviene richiesto con altri tipi di delegati.

Nota:questa funzionalità è disponibile dalla versione 2.7.

Python

LiteRT con operazioni TensorFlow selezionate verrà installato automaticamente con nel pacchetto pip TensorFlow. Puoi scegli anche di installare solo il pip LiteRT Interpreter pacchetto.

Metriche

Prestazioni

Se utilizzi una combinazione di operazioni TensorFlow integrate e selezionate, 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 corrispondono in media a 100 corse. Questi i target sono stati creati per Android utilizzando i flag: --config=android_arm64 -c opt.

Dimensioni binarie

La tabella seguente descrive le dimensioni binarie 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 i3d-kinetics-400 modello con 8 operazioni TFLite integrate e 3 operazioni TensorFlow. Per ulteriori dettagli, consulta Sezione Riduci le dimensioni binarie LiteRT.

Limitazioni note

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

Aggiornamenti

• Versione 2.6
  • Supporta gli operatori basati su attributi GraphDef e la risorsa HashTable sono migliorate.
• Versione 2.5
  • Puoi applicare un'ottimizzazione nota come post-training quantizzazione
• Versione 2.4
  • La compatibilità con i delegati con accelerazione hardware è stata migliorata