Delegat do akceleracji GPU za pomocą interfejsu API C/C++

Korzystanie z procesorów graficznych (GPU) do uruchamiania modeli systemów uczących się może znacznie poprawić wydajność i wygodę użytkowników Aplikacje obsługujące systemy uczące się. Na urządzeniach z Androidem możesz włączyć przyspieszanie za pomocą GPU. do uruchamiania modeli z wykorzystaniem delegowania oraz tych interfejsów API:

• Interpreter API – przewodnik
• Natywny interfejs API (C/C++) – ten przewodnik

Ten przewodnik opisuje zaawansowane zastosowania zdelegowanego GPU w interfejsach API w języku C, C++ API oraz na podstawie kwantyzowanych modeli. Więcej informacji o używaniu przedstawiciela GPU LiteRT, w tym sprawdzone metody i zaawansowane techniki, znajdziesz w poradniku GPU .

Włącz akcelerację GPU

Użyj delegata GPU LiteRT w przypadku Androida w C lub C++, tworząc przekazać dostęp za pomocą funkcji TfLiteGpuDelegateV2Create() i zniszczyć go za pomocą TfLiteGpuDelegateV2Delete() zgodnie z poniższym przykładowym kodem:

// 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);

Aby utworzyć instancję delegowaną, sprawdź kod obiektu TfLiteGpuDelegateOptionsV2 z opcjami niestandardowymi. Opcje domyślne można zainicjować TfLiteGpuDelegateOptionsV2Default(), a następnie w razie potrzeby je zmodyfikuj.

Funkcja przedstawiciela GPU LiteRT w przypadku Androida w języku C lub C++ używa funkcji system kompilacji Bazel. przedstawiciela możesz utworzyć za pomocą to polecenie:

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

Podczas połączenia z firmą Interpreter::ModifyGraphWithDelegate() lub Interpreter::Invoke(), rozmówca musi mieć przypisaną EGLContext thread i Interpreter::Invoke() muszą być wywoływane z tego samego elementu EGLContext. Jeśli identyfikator EGLContext nie istnieje, delegat tworzy go wewnętrznie, a następnie musisz się upewnić, że usługa Interpreter::Invoke() jest zawsze wywoływana z tego samego w wątku, w którym wywołano Interpreter::ModifyGraphWithDelegate().

Dzięki LiteRT w Usługach Google Play:

Jeśli używasz LiteRT w interfejsie C API Usług Google Play, musisz użyć interfejsu API Java/Kotlin, aby sprawdzić, czy delegat GPU jest dostępny dla urządzenia przed zainicjowaniem środowiska wykonawczego LiteRT.

Dodaj do swojej aplikacji zależności funkcji delegowania GPU:

implementation 'com.google.android.gms:play-services-tflite-gpu:16.2.0'

Następnie sprawdź dostępność GPU i zainicjuj TfLiteNative, jeśli udało się:

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)
    }
        

Musisz też zaktualizować konfigurację CMake, aby zawierała Flaga kompilatora TFLITE_USE_OPAQUE_DELEGATE:

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

Biblioteka FlatBuffers służy do konfigurowania delegować wtyczki, więc musisz je 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 prostu połączyć nagłówki z aplikacją.

Na koniec, aby użyć wnioskowania GPU w kodzie C, utwórz delegata GPU za pomocą polecenia 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 kwantowe

Biblioteki delegowanych GPU w Androidzie obsługują domyślnie modele kwantowe. Ty nie nie muszą wprowadzać żadnych zmian w kodzie, aby używać kwantyzowanych modeli z delegacją GPU. poniżej dowiesz się, jak wyłączyć kwantyzowaną obsługę testów lub do celów eksperymentalnych.

Wyłącz obsługę modeli kwantowych

Ten kod pokazuje, jak wyłączyć obsługę modeli kwantyzowanych.

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 kwantowych z akceleracją GPU znajdziesz w artykule Omówienie przekazywania dostępu do GPU.