משתמש שהענקת לו גישה להאצת GPU עם API של C/C++

שימוש ביחידות עיבוד גרפיות (GPU) להרצת מודלים של למידת מכונה (ML) יכולה לשפר באופן משמעותי את הביצועים ואת חוויית המשתמש אפליקציות שתומכות בלמידת מכונה. במכשירי Android, ניתן להפעיל שיפור המהירות באמצעות GPU את המודלים באמצעות הענקת גישה של ממשקי ה-API הבאים:

• interpreer API – מדריך
• Native (C/C++ ) – המדריך הזה

מדריך זה עוסק בשימושים מתקדמים בהאצלת GPU עבור C API, C++ API, ו לשימוש במודלים כמותיים. לקבלת מידע נוסף על השימוש בהענקת גישה ל-GPU עבור LiteRT, כולל שיטות מומלצות וטכניקות מתקדמות, זמין בGPU משתמשים שקיבלו הרשאה.

הפעלה של האצת GPU

השתמשו בהאציל של LiteRT GPU ל-Android ב-C או ב-C++ על ידי יצירת להעניק גישה עם TfLiteGpuDelegateV2Create() ולהשמיד אותו באמצעות TfLiteGpuDelegateV2Delete(), כפי שמוצג בקוד לדוגמה הבא:

// 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 עם אפשרויות מותאמות אישית. אפשר לאתחל את אפשרויות ברירת המחדל עם TfLiteGpuDelegateOptionsV2Default() ולאחר מכן לשנות אותם לפי הצורך.

מקבל הגישה ל-GPU של LiteRT ב-Android ב-C או ב-C++ משתמש מערכת build של Bazel. אפשר לתת למשתמש גישה באמצעות הפקודה הבאה:

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

בשיחה אל Interpreter::ModifyGraphWithDelegate() או Interpreter::Invoke(), למבצע הקריאה החוזרת צריך להיות EGLContext בשדה הנוכחי הקריאה ל-thread ול-Interpreter::Invoke() צריכה להיות מאותו EGLContext. אם המיקום לא קיים EGLContext, בעל הגישה יוצר דוח באופן פנימי, אבל אז עליך לוודא שהקריאה אל Interpreter::Invoke() תמיד תהיה מאותו סוג שרשור שבו נקרא Interpreter::ModifyGraphWithDelegate().

עם LiteRT ב-Google Play Services:

אם אתם משתמשים ב-LiteRT ב-C API של Google Play Services: יהיה עליך להשתמש ב-Java/Kotlin API כדי לבדוק אם קיימת גישה ל-GPU במכשיר לפני אתחול זמן הריצה של LiteRT.

מוסיפים לאפליקציה את יחסי התלות של הענקת גישה ל-GPU:

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

לאחר מכן, בודקים את זמינות ה-GPU ומפעילים את TfLiteNative אם הבדיקה מוצלח:

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

עליך לעדכן גם את ההגדרות האישיות של CMake כך שיכללו את דגל מהדר (compiler) TFLITE_USE_OPAQUE_DELEGATE:

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

הספרייה FlatBuffers משמשת להגדרה להעניק גישה ליישומי פלאגין, לכן צריך להוסיף אותו ליחסי התלות של קוד ה-Native שלכם. אפשר להשתמש בהגדרות האישיות הרשמיות של פרויקט CMake באופן הבא:

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

אפשר גם פשוט לקבץ את הכותרות עם האפליקציה.

לסיום, כדי להשתמש בהסקת המסקנות מ-GPU בקוד ה-C, יוצרים את נציג ה-GPU באמצעות 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);

מודלים כמותיים

ספריות להאציל של Android GPU תומכות במודלים כמותיים כברירת מחדל. לא תצטרכו לבצע שינויים בקוד כדי להשתמש במודלים כמותיים עם מקבל הגישה ל-GPU. בקטע הבא מוסבר איך להשבית תמיכה כמותית בבדיקה למטרות ניסיוניות.

השבתת התמיכה במודל כמותי

הקוד הבא מסביר איך להשבית את התמיכה במודלים כמותיים.

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

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

למידע נוסף על הרצת מודלים כמותיים עם האצת GPU, ראו: סקירה כללית בנושא הענקת גישה ל-GPU.