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

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

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

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

הפעלת שיפור המהירות באמצעות GPU

משתמשים בהאצלה של GPU ב-TensorFlow Lite ל-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 של TensorFlow Lite ל-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() מאותו thread שבו Interpreter::ModifyGraphWithDelegate() נקרא.

בעזרת TensorFlow Lite בשירותי Google Play:

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

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

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

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

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

בנוסף, צריך לעדכן את הגדרות ה-CMake כדי לכלול את סימון המהדר 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. בקטע הבא מוסבר איך להשבית תמיכה כמותית למטרות בדיקה או ניסוי.

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

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

C++

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

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

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