GPU-Beschleunigungsdelegat mit C/C++ API

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:

Task<Void> tfLiteHandleTask =
TfLiteGpu.isGpuDelegateAvailable(this)
   .onSuccessTask(gpuAvailable -> {
      TfLiteInitializationOptions options =
        TfLiteInitializationOptions.builder()
          .setEnableGpuDelegateSupport(gpuAvailable).build();
        return TfLiteNative.initialize(this, options);
      }
    );
      

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.

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.