Delegat akceleracji GPU z API C/C++

Używanie jednostek przetwarzania grafiki (GPU) do uruchamiania modeli uczenia maszynowego (ML) może radykalnie poprawić wydajność i komfort korzystania z aplikacji obsługujących technologię ML. Na urządzeniach z systemem Android możesz włączyć wykonywanie modeli przyspieszane przez procesor graficzny, korzystając z delegata i jednego z następujących interfejsów API:

  • Interpreter API - przewodnik
  • API biblioteki zadań - przewodnik
  • Natywne API (C/C++) – ten przewodnik

W tym przewodniku omówiono zaawansowane zastosowania delegata procesora GPU dla interfejsów API języka C i języka C++ oraz korzystanie z modeli skwantowanych. Aby uzyskać więcej informacji na temat korzystania z delegata procesora GPU dla TensorFlow Lite, w tym najlepszych praktyk i zaawansowanych technik, zobacz stronę delegatów procesora GPU .

Włącz akcelerację GPU

Użyj delegata GPU TensorFlow Lite dla Androida w C lub C++, tworząc delegata za pomocą TfLiteGpuDelegateV2Create() i niszcząc go za pomocą TfLiteGpuDelegateV2Delete() , jak pokazano w poniższym 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);

Przejrzyj kod obiektowy TfLiteGpuDelegateOptionsV2 , aby zbudować instancję delegata z opcjami niestandardowymi. Możesz zainicjować opcje domyślne za pomocą TfLiteGpuDelegateOptionsV2Default() , a następnie zmodyfikować je w razie potrzeby.

Delegat procesora GPU TensorFlow Lite dla systemu Android w języku C lub C++ korzysta z systemu kompilacji Bazel . Możesz zbudować delegata za pomocą następującego 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

Podczas wywoływania Interpreter::ModifyGraphWithDelegate() lub Interpreter::Invoke() obiekt wywołujący musi mieć EGLContext w bieżącym wątku, a Interpreter::Invoke() musi zostać wywołany z tego samego EGLContext . Jeśli EGLContext nie istnieje, delegat tworzy go wewnętrznie, ale wówczas należy upewnić się, że Interpreter::Invoke() jest zawsze wywoływana z tego samego wątku, w którym została wywołana 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, musisz użyć interfejsu API Java/Kotlin, aby sprawdzić, czy delegat GPU jest dostępny dla Twojego urządzenia przed zainicjowaniem środowiska wykonawczego TensorFlow Lite.

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

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

Następnie sprawdź dostępność procesora graficznego i zainicjuj TfLiteNative, jeśli sprawdzenie zakończy się pomyślnie:

Jawa

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

Kotlina

val tfLiteHandleTask = TfLiteGpu.isGpuDelegateAvailable(this)
    .onSuccessTask { gpuAvailable ->
        val options = TfLiteInitializationOptions.Builder()
            .setEnableGpuDelegateSupport(gpuAvailable)
            .build()
        TfLiteNative.initialize(this, options)
    }

Musisz także 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 wtyczek delegujących, dlatego należy ją dodać do zależności swojego natywnego kodu. 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 także po prostu dołączyć nagłówki do swojej aplikacji.

Na koniec, aby użyć wnioskowania 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 kwantowane

Biblioteki delegatów GPU dla systemu Android domyślnie obsługują modele skwantowane. Aby używać modeli skwantowanych z delegatem procesora GPU, nie trzeba wprowadzać żadnych zmian w kodzie. W poniższej sekcji wyjaśniono, jak wyłączyć obsługę kwantyzacji do celów testowych lub eksperymentalnych.

Wyłącz obsługę modelu skwantowanego

Poniższy kod pokazuje, jak wyłączyć obsługę modeli skwantowanych.

C++

TfLiteGpuDelegateOptionsV2 options = TfLiteGpuDelegateOptionsV2Default();
options.experimental_flags = TFLITE_GPU_EXPERIMENTAL_FLAGS_NONE;

auto* delegate = TfLiteGpuDelegateV2Create(options);
if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;

Aby uzyskać więcej informacji na temat uruchamiania modeli skwantowanych z akceleracją procesora GPU, zobacz Omówienie delegowania procesora GPU .