Delegat i përshpejtimit të GPU me API C/C++

Përdorimi i njësive të përpunimit grafik (GPU) për të ekzekutuar modelet tuaja të mësimit të makinerisë (ML) mund të përmirësojë në mënyrë dramatike performancën dhe përvojën e përdoruesit të aplikacioneve tuaja të aktivizuara me ML. Në pajisjet Android, mund të aktivizoni ekzekutimin e përshpejtuar nga GPU të modeleve tuaja duke përdorur një delegat dhe një nga API-të e mëposhtme:

• Interpreter API - udhëzues
• API amtare (C/C++) - ky udhëzues

Ky udhëzues mbulon përdorime të avancuara të delegatit të GPU për C API, C++ API dhe përdorimin e modeleve të kuantizuara. Për më shumë informacion rreth përdorimit të delegatit të GPU për LiteRT, duke përfshirë praktikat më të mira dhe teknikat e avancuara, shihni faqen e delegatëve të GPU .

Aktivizo përshpejtimin e GPU-së

Përdorni delegatin e LiteRT GPU për Android në C ose C++ duke krijuar delegatin me TfLiteGpuDelegateV2Create() dhe duke e shkatërruar atë me TfLiteGpuDelegateV2Delete() , siç tregohet në kodin e shembullit të mëposhtëm:

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

Rishikoni kodin e objektit TfLiteGpuDelegateOptionsV2 për të ndërtuar një shembull delegati me opsione të personalizuara. Mund të inicializoni opsionet e paracaktuara me TfLiteGpuDelegateOptionsV2Default() dhe më pas t'i modifikoni sipas nevojës.

Delegati i LiteRT GPU për Android në C ose C++ përdor sistemin e ndërtimit të Bazel . Ju mund të ndërtoni delegatin duke përdorur komandën e mëposhtme:

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

Kur telefononi Interpreter::ModifyGraphWithDelegate() ose Interpreter::Invoke() , thirrësi duhet të ketë një EGLContext në thread-in aktual dhe Interpreter::Invoke() duhet të thirret nga i njëjti EGLContext . Nëse një EGLContext nuk ekziston, delegati krijon një të tillë brenda, por atëherë duhet të siguroheni që Interpreter::Invoke() të thirret gjithmonë nga e njëjta thread në të cilën është thirrur Interpreter::ModifyGraphWithDelegate() .

Me LiteRT në Shërbimet e Google Play:

Nëse po përdorni LiteRT në Google Play Services C API , do t'ju duhet të përdorni Java/Kotlin API për të kontrolluar nëse një delegat GPU është i disponueshëm për pajisjen tuaj përpara se të inicializoni kohën e ekzekutimit të LiteRT.

Shtoni varësitë e shkallës së deleguar të GPU në aplikacionin tuaj:

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

Pastaj, kontrolloni disponueshmërinë e GPU-së dhe inicializoni TfLiteNative nëse kontrolli është i suksesshëm:

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

Ju gjithashtu duhet të përditësoni konfigurimin tuaj CMake për të përfshirë flamurin e përpiluesit TFLITE_USE_OPAQUE_DELEGATE :

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

Biblioteka FlatBuffers përdoret për të konfiguruar shtojcat e deleguara, kështu që ju duhet ta shtoni atë në varësitë e kodit tuaj vendas. Ju mund të përdorni konfigurimin zyrtar të projektit CMake si më poshtë:

target_include_directories(tflite-jni PUBLIC
        third_party/headers # flatbuffers
     ...)

Ju gjithashtu mund të bashkoni titujt në aplikacionin tuaj.

Më në fund për të përdorur konkluzionet e GPU në kodin tuaj C, krijoni delegatin e GPU duke përdorur 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 të kuantizuara

Bibliotekat e delegatëve të GPU-së Android mbështesin modelet e kuantizuara si parazgjedhje. Ju nuk keni nevojë të bëni ndonjë ndryshim kodi për të përdorur modele të kuantizuara me delegatin e GPU. Seksioni vijues shpjegon se si të çaktivizohet mbështetja e kuantizuar për qëllime testimi ose eksperimentale.

Çaktivizo mbështetjen e modelit të kuantizuar

Kodi i mëposhtëm tregon se si të çaktivizoni mbështetjen për modelet e kuantizuara.

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

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

Për më shumë informacion rreth ekzekutimit të modeleve të kuantizuara me përshpejtim GPU, shihni përmbledhjen e delegatëve të GPU .