GPU-Beschleunigungsdelegat mit C/C++ API

Grafikprozessoren (Graphics Processing Units, GPUs) zum Ausführen Ihrer Modelle für maschinelles Lernen (ML) verwenden die Leistung und Nutzererfahrung Ihrer Anzeigen erheblich verbessern, ML-fähige Anwendungen Auf Android-Geräten können Sie Ausführung Ihrer Modelle mit einem Delegierten und einem der folgenden APIs:

• Interpreter API – Leitfaden
• Native (C/C++) API - dieser Leitfaden

In diesem Leitfaden wird die erweiterte Verwendung des GPU-Delegaten für die C API, die C++ API und quantisierten Modellen nutzen. Weitere Informationen zur Verwendung des GPU-Delegaten für LiteRT, einschließlich Best Practices und fortgeschrittener Techniken, siehe GPU Seite „Bevollmächtigte“.

GPU-Beschleunigung aktivieren

Verwenden Sie den LiteRT GPU-Delegaten für Android in C oder C++, indem Sie die Methode mit TfLiteGpuDelegateV2Create() delegieren und zerstören 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);

TfLiteGpuDelegateOptionsV2-Objektcode prüfen, um eine delegierte Instanz zu erstellen mit benutzerdefinierten Optionen. Sie können die Standardoptionen mit TfLiteGpuDelegateOptionsV2Default() und ändern Sie sie nach Bedarf.

Der LiteRT GPU-Delegate für Android in C oder C++ verwendet den Bazel-Build-System Sie können den Delegaten mithilfe der Methode folgenden Befehl:

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(), für den Aufrufer muss eine EGLContext im aktuellen Thread und Interpreter::Invoke() müssen vom selben EGLContext aus aufgerufen werden. Wenn EGLContext nicht vorhanden ist, erstellt der Bevollmächtigte intern ein solches, aber dann müssen Sie darauf achten, dass Interpreter::Invoke() immer vom selben Thread, in dem Interpreter::ModifyGraphWithDelegate() aufgerufen wurde.

Mit LiteRT in den Google Play-Diensten:

Wenn Sie LiteRT in der C API der Google Play Services verwenden, Sie müssen mit der Java/Kotlin API prüfen, ob ein GPU-Delegierung verfügbar ist. vor der Initialisierung der LiteRT-Laufzeit für Ihr Gerät.

Fügen Sie Ihrer Anwendung die Gradle-Abhängigkeiten des GPU-Delegaten 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:

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 die CMake-Konfiguration aktualisieren, um den Parameter Compiler-Flag TFLITE_USE_OPAQUE_DELEGATE:

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

Mit der Bibliothek FlatBuffers Delegieren von Plug-ins, sodass Sie es den Abhängigkeiten Ihres nativen Codes hinzufügen müssen. 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 die GPU-Inferenz in Ihrem C-Code zu verwenden, erstellen Sie den TFLiteSettings:

#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 Delegate-Bibliotheken unterstützen standardmäßig quantisierte Modelle. Du nicht Änderungen am Code vornehmen, um quantisierte Modelle mit dem GPU-Delegaten zu verwenden. Die Im folgenden Abschnitt wird erläutert, wie Sie die quantisierte Unterstützung für Tests oder zu experimentellen Zwecken.

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 unter GPU Delegate