Zastosowanie procesorów graficznych (GPU) do uruchamiania modeli systemów uczących się może znacznie zwiększyć wydajność i wygodę użytkowników aplikacji obsługujących systemy uczące się. Na urządzeniach z Androidem możesz włączyć przyspieszanie przez GPU wykonywanie modeli za pomocą osoby, której przekazano dostęp i jednego z tych interfejsów API:
- Interpreter API – przewodnik
- Natywny interfejs API (C/C++) – ten przewodnik
W tym przewodniku omawiamy zaawansowane zastosowania delegata GPU do interfejsów API C i C++ oraz korzystania z modeli skwantyzowanych. Więcej informacji o korzystaniu z delegata GPU dla TensorFlow Lite, w tym o sprawdzonych metodach i zaawansowanych technikach, znajdziesz na stronie delegatów GPU.
Włącz akcelerację GPU
Użyj delegata GPU TensorFlow Lite dla Androida w języku C lub C++, tworząc delegat za pomocą TfLiteGpuDelegateV2Create()
i niszcząc go za pomocą TfLiteGpuDelegateV2Delete()
, jak w tym przykładowym kodzie:
// 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);
Sprawdź kod obiektu TfLiteGpuDelegateOptionsV2
, aby utworzyć instancję delegata z opcjami niestandardowymi. Opcje domyślne możesz zainicjować za pomocą TfLiteGpuDelegateOptionsV2Default()
, a potem w razie potrzeby je zmodyfikować.
Delegat GPU TensorFlow Lite dla Androida w języku C lub C++ korzysta z systemu kompilacji Bazel. Delegata możesz utworzyć za pomocą tego polecenia:
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
Aby można było wywołać metodę Interpreter::ModifyGraphWithDelegate()
lub Interpreter::Invoke()
, element wywołujący musi mieć w bieżącym wątku EGLContext
, a Interpreter::Invoke()
musi być wywoływany z tego samego parametru EGLContext
. Jeśli obiekt EGLContext
nie istnieje, delegat utworzy go wewnętrznie, ale musisz zadbać o to, aby funkcja Interpreter::Invoke()
była zawsze wywoływana z tego samego wątku, w którym wywołano metodę Interpreter::ModifyGraphWithDelegate()
.
Dzięki TensorFlow Lite w Usługach Google Play:
Jeśli używasz TensorFlow Lite w interfejsie API C Usług Google Play, to przed zainicjowaniem środowiska wykonawczego TensorFlow Lite musisz użyć interfejsu API Java/Kotlin, aby sprawdzić, czy dla Twojego urządzenia dostępny jest delegat GPU.
Dodaj do aplikacji zależności GPU delegowane przez Gradle:
implementation 'com.google.android.gms:play-services-tflite-gpu:16.2.0'
Następnie sprawdź dostępność GPU i zainicjuj TfLiteNative, jeśli test się uda:
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) }
Musisz też zaktualizować konfigurację CMake, aby uwzględnić flagę kompilatora TFLITE_USE_OPAQUE_DELEGATE
:
add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)
Biblioteka FlatBuffers służy do konfigurowania przekazanych wtyczek, więc musisz ją dodać do zależności kodu natywnego.
Możesz użyć oficjalnej konfiguracji projektu CMake
w następujący sposób:
target_include_directories(tflite-jni PUBLIC
third_party/headers # flatbuffers
...)
Możesz też połączyć nagłówki z aplikacją.
Aby użyć wnioskowania na podstawie GPU w kodzie C, utwórz delegata GPU za pomocą 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);
Modele kwantyzowane
Biblioteki delegowania GPU w Androidzie domyślnie obsługują modele poddane kwantyzacji. Aby używać skwantyzowanych modeli z delegatem GPU, nie musisz wprowadzać żadnych zmian w kodzie. W sekcji poniżej wyjaśniono, jak wyłączyć obsługę ilościową na potrzeby testowania lub eksperymentu.
Wyłącz obsługę modelu skwantyzowanego
Poniższy kod pokazuje, jak wyłączyć obsługę modeli skwantyzowanych.
C++
TfLiteGpuDelegateOptionsV2 options = TfLiteGpuDelegateOptionsV2Default(); options.experimental_flags = TFLITE_GPU_EXPERIMENTAL_FLAGS_NONE; auto* delegate = TfLiteGpuDelegateV2Create(options); if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;
Więcej informacji o uruchamianiu modeli skwantyzowanych z akceleracją GPU znajdziesz w artykule o przekazywaniu delegacji GPU.