Die Verwendung von Grafikprozessoren (GPUs) zum Ausführen Ihrer Modelle für maschinelles Lernen (ML) kann die Leistung und Nutzerfreundlichkeit Ihrer ML-fähigen Anwendungen erheblich verbessern. Auf Android-Geräten können Sie die GPU-beschleunigte Ausführung Ihrer Modelle mithilfe eines Delegierten und einer der folgenden APIs aktivieren:
- Interpreter API – Leitfaden
- Native API (C/C++) – diese Anleitung
In diesem Leitfaden werden erweiterte Verwendungen des GPU-Delegaten für die C API und die C++ API sowie die Verwendung quantisierter Modelle behandelt. Weitere Informationen zur Verwendung des GPU-Delegaten für TensorFlow Lite, einschließlich Best Practices und erweiterter Techniken, finden Sie auf der Seite GPU-Bevollmächtigte.
GPU-Beschleunigung aktivieren
Verwenden Sie den TensorFlow Lite GPU-Delegaten für Android in C oder C++. Erstellen Sie dazu den Bevollmächtigten mit TfLiteGpuDelegateV2Create()
und löschen Sie ihn mit TfLiteGpuDelegateV2Delete()
, wie im folgenden Beispielcode gezeigt:
// Set up interpreter.
auto model = FlatBufferModel::BuildFromFile(model_path);
if (!model) return false;
ops::builtin::BuiltinOpResolver op_resolver;
std::unique_ptr<Interpreter> interpreter;
InterpreterBuilder(*model, op_resolver)(&interpreter);
// NEW: Prepare GPU delegate.
auto* delegate = TfLiteGpuDelegateV2Create(/*default options=*/nullptr);
if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;
// Run inference.
WriteToInputTensor(interpreter->typed_input_tensor<float>(0));
if (interpreter->Invoke() != kTfLiteOk) return false;
ReadFromOutputTensor(interpreter->typed_output_tensor<float>(0));
// NEW: Clean up.
TfLiteGpuDelegateV2Delete(delegate);
Überprüfen Sie den TfLiteGpuDelegateOptionsV2
-Objektcode, um eine delegierte Instanz mit benutzerdefinierten Optionen zu erstellen. Sie können die Standardoptionen mit TfLiteGpuDelegateOptionsV2Default()
initialisieren und sie dann nach Bedarf ändern.
Der TensorFlow Lite GPU-Delegate für Android in C oder C++ verwendet das Bazel. Sie können den Delegaten mit dem folgenden Befehl erstellen:
bazel build -c opt --config android_arm64 tensorflow/lite/delegates/gpu:delegate # for static library
bazel build -c opt --config android_arm64 tensorflow/lite/delegates/gpu:libtensorflowlite_gpu_delegate.so # for dynamic library
Beim Aufrufen von Interpreter::ModifyGraphWithDelegate()
oder Interpreter::Invoke()
muss der Aufrufer eine EGLContext
im aktuellen Thread haben und Interpreter::Invoke()
muss vom selben EGLContext
aus aufgerufen werden. Wenn EGLContext
nicht vorhanden ist, erstellt der Bevollmächtigte intern einen solchen. Sie müssen dann aber dafür sorgen, dass Interpreter::Invoke()
immer aus demselben Thread aufgerufen wird, in dem Interpreter::ModifyGraphWithDelegate()
aufgerufen wurde.
Mit TensorFlow Lite in den Google Play-Diensten:
Wenn Sie TensorFlow Lite in der C API der Google Play Services verwenden, müssen Sie vor der Initialisierung der TensorFlow Lite-Laufzeit mit der Java/Kotlin API prüfen, ob ein GPU-Delegate für Ihr Gerät verfügbar ist.
Fügen Sie Ihrer Anwendung die Abhängigkeiten des GPU-delegierten Gradle-Vorgangs hinzu:
implementation 'com.google.android.gms:play-services-tflite-gpu:16.2.0'
Prüfen Sie dann die GPU-Verfügbarkeit und initialisieren Sie TfLiteNative, wenn die Prüfung erfolgreich ist:
Java
Task<Void> tfLiteHandleTask = TfLiteGpu.isGpuDelegateAvailable(this) .onSuccessTask(gpuAvailable -> { TfLiteInitializationOptions options = TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(gpuAvailable).build(); return TfLiteNative.initialize(this, options); } );
Kotlin
val tfLiteHandleTask = TfLiteGpu.isGpuDelegateAvailable(this) .onSuccessTask { gpuAvailable -> val options = TfLiteInitializationOptions.Builder() .setEnableGpuDelegateSupport(gpuAvailable) .build() TfLiteNative.initialize(this, options) }
Außerdem müssen Sie Ihre CMake-Konfiguration so aktualisieren, dass sie das Compiler-Flag TFLITE_USE_OPAQUE_DELEGATE
enthält:
add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)
Die FlatBuffers-Bibliothek wird zum Konfigurieren von Delegat-Plug-ins verwendet. Deshalb müssen Sie sie den Abhängigkeiten Ihres nativen Codes hinzufügen.
Sie können die offizielle CMake
-Projektkonfiguration so verwenden:
target_include_directories(tflite-jni PUBLIC
third_party/headers # flatbuffers
...)
Sie können die Header auch einfach in Ihrer App bündeln.
Um schließlich GPU-Inferenzen in Ihrem C-Code zu verwenden, erstellen Sie mit TFLiteSettings
den GPU-Delegaten:
#include "flatbuffers/flatbuffers.h"
#include "tensorflow/lite/acceleration/configuration/configuration_generated.h"
flatbuffers::FlatBufferBuilder fbb;
tflite::TFLiteSettingsBuilder builder(fbb);
const tflite::TFLiteSettings* tflite_settings =
flatbuffers::GetTemporaryPointer(fbb, builder.Finish());
const TfLiteOpaqueDelegatePlugin* pluginCApi = TfLiteGpuDelegatePluginCApi();
TfLiteOpaqueDelegate* gpu_delegate = pluginCApi->create(tflite_settings);
Quantisierte Modelle
Android-GPU-Delegierungsbibliotheken unterstützen standardmäßig quantisierte Modelle. Sie müssen keine Codeänderungen vornehmen, um quantisierte Modelle mit dem GPU-Delegaten zu verwenden. Im folgenden Abschnitt wird erläutert, wie Sie die quantisierte Unterstützung für Test- oder experimentelle Zwecke deaktivieren.
Unterstützung quantisierter Modelle deaktivieren
Der folgende Code zeigt, wie Sie die Unterstützung für quantisierte Modelle deaktivieren.
C++
TfLiteGpuDelegateOptionsV2 options = TfLiteGpuDelegateOptionsV2Default(); options.experimental_flags = TFLITE_GPU_EXPERIMENTAL_FLAGS_NONE; auto* delegate = TfLiteGpuDelegateV2Create(options); if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;
Weitere Informationen zum Ausführen quantisierter Modelle mit GPU-Beschleunigung finden Sie in der Übersicht zum GPU-Delegaten.