Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Wählen Sie TensorFlow-Operatoren aus

Da die in TensorFlow Lite integrierte Operatorbibliothek nur eine begrenzte Anzahl von TensorFlow-Operatoren unterstützt, ist nicht jedes Modell konvertierbar. Weitere Informationen finden Sie unter Bedienerkompatibilität .

Um die Konvertierung zu ermöglichen, können Benutzer die Verwendung bestimmter TensorFlow-Operationen in ihrem TensorFlow Lite-Modell aktivieren. Zum Ausführen von TensorFlow Lite-Modellen mit TensorFlow-Operationen muss jedoch die Kernlaufzeit von TensorFlow eingezogen werden, wodurch die Binärgröße des TensorFlow Lite-Interpreters erhöht wird. Für Android können Sie dies vermeiden, indem Sie selektiv nur die erforderlichen Tensorflow-Operationen erstellen. Einzelheiten finden Sie unter Reduzieren der Binärgröße .

In diesem Dokument wird beschrieben, wie Sie ein TensorFlow Lite-Modell mit TensorFlow-Operationen auf einer Plattform Ihrer Wahl konvertieren und ausführen . Außerdem werden Leistungs- und Größenmetriken sowie bekannte Einschränkungen erläutert.

Modell konvertieren

Das folgende Beispiel zeigt, wie ein TensorFlow Lite-Modell mit ausgewählten TensorFlow-Operationen generiert wird.

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)

Inferenz ausführen

Wenn Sie ein TensorFlow Lite-Modell verwenden, das mit Unterstützung für ausgewählte TensorFlow-Operationen konvertiert wurde, muss der Client auch eine TensorFlow Lite-Laufzeit verwenden, die die erforderliche Bibliothek von TensorFlow-Operationen enthält.

Android AAR

Um die Binärgröße zu verringern, erstellen Sie bitte Ihre eigenen benutzerdefinierten AAR-Dateien, wie im nächsten Abschnitt beschrieben . Wenn die Binärgröße keine große Rolle spielt , empfehlen wir die Verwendung des vorgefertigten AAR mit TensorFlow-Operationen, die bei JCenter gehostet werden .

Sie können dies in Ihren build.gradle Abhängigkeiten angeben, indem Sie es wie folgt neben dem Standard-TensorFlow Lite-AAR hinzufügen:

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly'
    // This dependency adds the necessary TF op support.
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.0.0-nightly'
}

Sobald Sie die Abhängigkeit hinzugefügt haben, sollte der erforderliche Delegat für die Behandlung der TensorFlow-Operationen des Diagramms automatisch für Diagramme installiert werden, für die sie erforderlich sind.

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

Erstellen des Android AAR

Um die Binärgröße oder andere erweiterte Fälle zu reduzieren, können Sie die Bibliothek auch manuell erstellen. Unter der Annahme einer funktionierenden TensorFlow Lite-Build-Umgebung erstellen Sie den Android-AAR mit ausgewählten TensorFlow-Operationen wie folgt:

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

Dadurch wird die AAR-Datei bazel-bin/tmp/tensorflow-lite.aar für integrierte und benutzerdefinierte TensorFlow Lite- bazel-bin/tmp/tensorflow-lite.aar . und generieren Sie die AAR-Datei bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar für TensorFlow bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar . Wenn Sie keine funktionierende Build-Umgebung haben, können Sie die obigen Dateien auch mit Docker erstellen .

Von dort aus können Sie entweder die AAR-Dateien direkt in Ihr Projekt importieren oder die benutzerdefinierten AAR-Dateien in Ihrem lokalen Maven-Repository veröffentlichen:

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

build.gradle Sie schließlich im mavenLocal() Ihrer App build.gradle , dass Sie die Abhängigkeit mavenLocal() und ersetzen Sie die Standardabhängigkeit TensorFlow Lite durch die Abhängigkeit, die ausgewählte TensorFlow-Operationen unterstützt:

allprojects {
    repositories {
        jcenter()
        mavenLocal()
    }
}

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.1.100'
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.1.100'
}

iOS

Verwenden von CocoaPods

Wir bieten jeden Abend vorgefertigte ausgewählte TF ops CocoaPods an, auf die Sie sich neben den TensorFlowLiteSwift oder TensorFlowLiteObjC CocoaPods verlassen können.

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

Nach dem Ausführen der pod install müssen Sie ein zusätzliches Linker-Flag bereitstellen, um das Laden des ausgewählten TF ops-Frameworks in Ihr Projekt zu erzwingen. Gehen Sie in Ihrem Xcode-Projekt zu Build Settings -> Other Linker Flags und fügen Sie Other Linker Flags hinzu:

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

Sie sollten dann in der Lage sein, alle mit SELECT_TF_OPS konvertierten Modelle in Ihrer iOS-App SELECT_TF_OPS . Sie können beispielsweise die iOS-App zur Bildklassifizierung ändern, um die Funktion zum Auswählen von TF-Operationen zu testen.

  • Ersetzen Sie die Modelldatei durch die mit aktivierter SELECT_TF_OPS konvertierte.
  • Fügen Sie der Podfile TensorFlowLiteSelectTfOps Abhängigkeit wie angewiesen hinzu.
  • Fügen Sie das zusätzliche Linker-Flag wie oben hinzu.
  • Führen Sie die Beispiel-App aus und prüfen Sie, ob das Modell ordnungsgemäß funktioniert.

Verwenden von Bazel + Xcode

TensorFlow Lite mit ausgewählten TensorFlow-Operationen für iOS kann mit Bazel erstellt werden. Befolgen Sie zunächst die Anweisungen zum .bazelrc iOS, um Ihren Bazel-Arbeitsbereich und .bazelrc Datei korrekt zu konfigurieren.

Nachdem Sie den Arbeitsbereich mit aktivierter iOS-Unterstützung konfiguriert haben, können Sie mit dem folgenden Befehl das ausgewählte TF ops-Addon-Framework erstellen, das über dem regulären TensorFlowLiteC.framework hinzugefügt werden kann. Beachten Sie, dass das ausgewählte TF ops-Framework nicht für die i386 Architektur erstellt werden kann. Daher müssen Sie die Liste der Zielarchitekturen ohne i386 explizit i386 .

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

Dadurch wird das Framework im bazel-bin/tensorflow/lite/experimental/ios/ generiert. Sie können dieses neue Framework zu Ihrem Xcode-Projekt hinzufügen, indem Sie ähnliche Schritte ausführen, die im Abschnitt Xcode-Projekteinstellungen im iOS-Build-Handbuch beschrieben sind.

Nach dem Hinzufügen des Frameworks zu Ihrem App-Projekt sollte in Ihrem App-Projekt ein zusätzliches Linker-Flag angegeben werden, um das Laden des ausgewählten TF ops-Frameworks zu erzwingen. Gehen Sie in Ihrem Xcode-Projekt zu Build Settings -> Other Linker Flags und fügen Sie Other Linker Flags hinzu:

-force_load <path/to/your/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps>

C ++

Beim Erstellen von TensorFlow Lite-Bibliotheken mithilfe der Bazel-Pipeline kann die zusätzliche TensorFlow Ops-Bibliothek wie folgt eingeschlossen und aktiviert werden:

  • --config=monolithic bei Bedarf monolithische Builds, indem Sie das --config=monolithic build hinzufügen.
  • Fügen Sie die Abhängigkeit der TensorFlow ops-Delegatenbibliothek zu den Build-Abhängigkeiten hinzu: tensorflow/lite/delegates/flex:delegate .

Beachten Sie, dass das erforderliche TfLiteDelegate beim Erstellen des Interpreters zur Laufzeit automatisch installiert wird, solange der Delegat mit der TfLiteDelegate verknüpft ist. Es ist nicht erforderlich, die Delegateninstanz explizit zu installieren, wie dies normalerweise bei anderen Delegattypen erforderlich ist.

Python

TensorFlow Lite mit ausgewählten TensorFlow-Operationen wird automatisch mit dem TensorFlow-Pip-Paket installiert. Sie können auch festlegen, dass nur das Pip-Paket TensorFlow Lite Interpreter installiert wird.

Metriken

Performance

Wenn Sie eine Mischung aus integrierten und ausgewählten TensorFlow-Operationen verwenden, sind alle gleichen TensorFlow Lite-Optimierungen und optimierten integrierten Operationen verfügbar und können mit dem konvertierten Modell verwendet werden.

In der folgenden Tabelle wird die durchschnittliche Zeit beschrieben, die zum Ausführen von Inferenzen in MobileNet auf einem Pixel 2 benötigt wird. Die angegebenen Zeiten sind durchschnittlich 100 Läufe. Diese Ziele wurden für Android mit den folgenden Flags erstellt: --config=android_arm64 -c opt .

Bauen Zeit (Millisekunden)
Nur integrierte TFLITE_BUILTIN ( TFLITE_BUILTIN ) 260,7
Nur TF- SELECT_TF_OPS ( SELECT_TF_OPS ) 264.5

Binärgröße

In der folgenden Tabelle wird die Binärgröße von TensorFlow Lite für jeden Build beschrieben. Diese Ziele wurden für Android mit --config=android_arm -c opt .

Bauen C ++ Binärgröße Android APK Größe
Nur eingebaute Operationen 796 KB 561 KB
Eingebaute Operationen + TF-Operationen 23,0 MB 8,0 MB
Eingebaute Operationen + TF-Operationen (1) 4,1 MB 1,8 MB

(1) Diese Bibliotheken wurden selektiv für das Modell i3d-kinetics-400 mit 8 integrierten TFLite-Operationen und 3 Tensorflow-Operationen erstellt. Weitere Informationen finden Sie im Abschnitt Reduzieren der TensorFlow Lite-Binärgröße .

Bekannte Einschränkungen

  • Nicht unterstützte Typen: Bestimmte TensorFlow-Operationen unterstützen möglicherweise nicht alle Ein- / Ausgabetypen, die normalerweise in TensorFlow verfügbar sind.
  • Nicht unterstützte Operationen: Kontrollflussoperationen und Operationen, die eine explizite Initialisierung von Ressourcen erfordern, wie HashTableV2 B. HashTableV2 , werden noch nicht unterstützt.
  • Nicht unterstützte Optimierungen: Wenn Sie eine Optimierung anwenden, die als Quantisierung nach dem Training bezeichnet wird , werden nur die TensorFlow Lite-Operationen quantisiert (oder optimiert), die TensorFlow-Operationen bleiben jedoch als Float (oder nicht optimiert).

Zukunftspläne

Im Folgenden finden Sie eine Liste der Verbesserungen an dieser Pipeline, die derzeit ausgeführt werden:

  • Verbesserte Leistung - Es wird daran gearbeitet, sicherzustellen, dass TensorFlow Lite mit TensorFlow-Operationen gut mit hardwarebeschleunigten Delegierten zusammenarbeitet, z. B. NNAPI- und GPU-Delegierten.