احفظ التاريخ! يعود مؤتمر Google I / O من 18 إلى 20 مايو. سجل الآن
ترجمت واجهة Cloud Translation API‏ هذه الصفحة.
Switch to English

مندوب TensorFlow Lite GPU

يدعم TensorFlow Lite العديد من مسرعات الأجهزة. يصف هذا المستند كيفية استخدام الواجهة الخلفية لوحدة معالجة الرسومات باستخدام واجهات برمجة تطبيقات تفويض TensorFlow Lite على Android و iOS.

تم تصميم وحدات معالجة الرسومات للحصول على إنتاجية عالية لأحمال العمل القابلة للتوازي بشكل كبير. وبالتالي ، فهي مناسبة تمامًا للشبكات العصبية العميقة ، والتي تتكون من عدد كبير من المشغلين ، كل منهم يعمل على بعض موتر (موترات) الإدخال التي يمكن تقسيمها بسهولة إلى أعباء عمل أصغر ويتم تنفيذها بشكل متوازٍ ، مما يؤدي عادةً إلى تقليل زمن الوصول. في أفضل السيناريوهات ، قد يعمل الاستدلال على وحدة معالجة الرسومات الآن بسرعة كافية لتطبيقات الوقت الفعلي التي لم تكن متاحة مسبقًا.

على عكس وحدات المعالجة المركزية (CPU) ، تحسب وحدات معالجة الرسومات بأرقام فاصلة عائمة 16 بت أو 32 بت ولا تتطلب تكميمًا للحصول على الأداء الأمثل. المندوب لا يقبل النماذج الكمية 8 بتات ، ولكن سيتم إجراء الحساب بأرقام الفاصلة العائمة. الرجوع إلى الوثائق المتقدمة للحصول على التفاصيل.

فائدة أخرى لاستدلال GPU هي كفاءتها في الطاقة. تقوم وحدات معالجة الرسومات (GPU) بإجراء العمليات الحسابية بطريقة فعالة ومحسّنة للغاية ، بحيث تستهلك طاقة أقل وتولد حرارة أقل مما يحدث عند تشغيل نفس المهمة على وحدات المعالجة المركزية.

دروس التطبيق التجريبي

أسهل طريقة لتجربة مفوض GPU هي اتباع البرامج التعليمية أدناه ، والتي تمر عبر إنشاء تطبيقات تجريبية للتصنيف مع دعم GPU. رمز GPU هو ثنائي فقط في الوقت الحالي ؛ سيكون مفتوح المصدر قريبًا. بمجرد أن تفهم كيفية تشغيل عروضنا التوضيحية ، يمكنك تجربة ذلك على نماذجك المخصصة.

Android (مع Android Studio)

للحصول على برنامج تعليمي خطوة بخطوة ، شاهد فيديو مندوب GPU لفيديو Android .

الخطوة 1. استنساخ كود مصدر TensorFlow وافتحه في Android Studio

git clone https://github.com/tensorflow/tensorflow

الخطوة الثانية. قم بتحرير app/build.gradle لاستخدام GPU AAR ليلاً

أضف tensorflow-lite-gpu إلى جانب حزمة tensorflow-lite الموجودة في كتلة dependencies الحالية.

dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite:2.3.0'
    implementation 'org.tensorflow:tensorflow-lite-gpu:2.3.0'
}

الخطوة 3. البناء والتشغيل

تشغيل → تشغيل "التطبيق". عند تشغيل التطبيق ، سترى زرًا لتمكين وحدة معالجة الرسومات. قم بالتغيير من النموذج الكمي إلى النموذج العائم ثم انقر فوق GPU للتشغيل على وحدة معالجة الرسومات.

تشغيل android gpu demo والتبديل إلى gpu

iOS (مع XCode)

للحصول على برنامج تعليمي خطوة بخطوة ، شاهد فيديو مندوب GPU لفيديو iOS .

الخطوة 1. احصل على الكود المصدري التجريبي وتأكد من تجميعه.

اتبع البرنامج التعليمي الخاص بتطبيق iOS التجريبي. سيوصلك هذا إلى نقطة حيث يعمل العرض التوضيحي لكاميرا iOS غير المعدلة على هاتفك.

الخطوة 2. قم بتعديل Podfile لاستخدام TensorFlow Lite GPU CocoaPod

بدءًا من الإصدار 2.3.0 ، يتم استبعاد مفوض GPU افتراضيًا من البود لتقليل الحجم الثنائي. يمكنك تضمينها عن طريق تحديد نوع فرعي. بالنسبة TensorFlowLiteSwift :

pod 'TensorFlowLiteSwift/Metal', '~> 0.0.1-nightly',

أو

pod 'TensorFlowLiteSwift', '~> 0.0.1-nightly', :subspecs => ['Metal']

يمكنك القيام بالمثل مع TensorFlowLiteObjC أو TensorFlowLitC إذا كنت تريد استخدام Objective-C (من الإصدار 2.4.0) أو C API.

قبل الإصدار 2.3.0

حتى TensorFlow Lite 2.0.0

لقد قمنا ببناء CocoaPod ثنائي يتضمن مندوب GPU. لتبديل المشروع لاستخدامه ، قم بتعديل ملف `tensorflow / tensorflow / lite / أمثلة / ios / camera / Podfile` لاستخدام حجرة` TensorFlowLiteGpuExperimental` بدلاً من `TensorFlowLite`.


    target 'YourProjectName'
      # pod 'TensorFlowLite', '1.12.0'
      pod 'TensorFlowLiteGpuExperimental'
    

حتى TensorFlow Lite 2.2.0

من TensorFlow Lite 2.1.0 إلى 2.2.0 ، يتم تضمين مفوض GPU في حجرة "TensorFlowLiteC". يمكنك الاختيار بين "TensorFlowLiteC" و "TensorFlowLiteSwift" حسب اللغة.

الخطوة 3. قم بتمكين مفوض GPU

لتمكين الرمز الذي سيستخدم مفوض GPU ، ستحتاج إلى تغيير TFLITE_USE_GPU_DELEGATE من 0 إلى 1 في CameraExampleViewController.h .

#define TFLITE_USE_GPU_DELEGATE 1

الخطوة 4. إنشاء التطبيق التجريبي وتشغيله

بعد اتباع الخطوة السابقة ، يجب أن تكون قادرًا على تشغيل التطبيق.

الخطوة 5. وضع الإصدار

أثناء تشغيلك في الخطوة 4 في وضع التصحيح ، للحصول على أداء أفضل ، يجب عليك التغيير إلى إصدار مع الإعدادات المعدنية المثلى المناسبة. على وجه الخصوص ، لتعديل هذه الإعدادات ، انتقل إلى Product > Scheme > Edit Scheme... حدد Run . في علامة التبويب Info ، قم بتغيير Build Configuration ، من Debug إلى Release ، قم بإلغاء تحديد Debug executable .

إعداد الإصدار

ثم انقر فوق علامة التبويب Options وقم بتغيير GPU Frame Capture إلى Disabled و Metal API Validation إلى Disabled .

إعداد خيارات معدنية

أخيرًا ، تأكد من تحديد الإصدار فقط يبني على بنية 64 بت. ضمن Project navigator -> tflite_camera_example -> PROJECT -> tflite_camera_example -> Build Settings اضبط Build Active Architecture Only > Release إلى نعم.

إعداد خيارات الإصدار

تجربة مندوب GPU على الطراز الخاص بك

ذكري المظهر

هناك طريقتان لاستدعاء تسريع النموذج بناءً على ما إذا كنت تستخدم Android Studio ML Model Binding أو TensorFlow Lite Interpreter.

مترجم TensorFlow Lite

انظر إلى العرض التوضيحي لمعرفة كيفية إضافة المفوض. في تطبيقك ، أضف AAR على النحو الوارد أعلاه ، org.tensorflow.lite.gpu.GpuDelegate وحدة org.tensorflow.lite.gpu.GpuDelegate ، واستخدم وظيفة addDelegate لتسجيل مفوض GPU في المترجم addDelegate :

كوتلن

    import org.tensorflow.lite.Interpreter
    import org.tensorflow.lite.gpu.CompatibilityList
    import org.tensorflow.lite.gpu.GpuDelegate

    val compatList = CompatibilityList()

    val options = Interpreter.Options().apply{
        if(compatList.isDelegateSupportedOnThisDevice){
            // if the device has a supported GPU, add the GPU delegate
            val delegateOptions = compatList.bestOptionsForThisDevice
            this.addDelegate(GpuDelegate(delegateOptions))
        } else {
            // if the GPU is not supported, run on 4 threads
            this.setNumThreads(4)
        }
    }

    val interpreter = Interpreter(model, options)

    // Run inference
    writeToInput(input)
    interpreter.run(input, output)
    readFromOutput(output)
      

جافا

    import org.tensorflow.lite.Interpreter;
    import org.tensorflow.lite.gpu.CompatibilityList;
    import org.tensorflow.lite.gpu.GpuDelegate;

    // Initialize interpreter with GPU delegate
    Interpreter.Options options = new Interpreter.Options();
    CompatibilityList compatList = CompatibilityList();

    if(compatList.isDelegateSupportedOnThisDevice()){
        // if the device has a supported GPU, add the GPU delegate
        GpuDelegate.Options delegateOptions = compatList.getBestOptionsForThisDevice();
        GpuDelegate gpuDelegate = new GpuDelegate(delegateOptions);
        options.addDelegate(gpuDelegate);
    } else {
        // if the GPU is not supported, run on 4 threads
        options.setNumThreads(4);
    }

    Interpreter interpreter = new Interpreter(model, options);

    // Run inference
    writeToInput(input);
    interpreter.run(input, output);
    readFromOutput(output);
      

iOS

سويفت

    import TensorFlowLite

    // Load model ...

    // Initialize TensorFlow Lite interpreter with the GPU delegate.
    let delegate = MetalDelegate()
    if let interpreter = try Interpreter(modelPath: modelPath,
                                         delegates: [delegate]) {
      // Run inference ...
    }
      

ج موضوعية

    // Import module when using CocoaPods with module support
    @import TFLTensorFlowLite;

    // Or import following headers manually
    #import "tensorflow/lite/objc/apis/TFLMetalDelegate.h"
    #import "tensorflow/lite/objc/apis/TFLTensorFlowLite.h"

    // Initialize GPU delegate
    TFLMetalDelegate* metalDelegate = [[TFLMetalDelegate alloc] init];

    // Initialize interpreter with model path and GPU delegate
    TFLInterpreterOptions* options = [[TFLInterpreterOptions alloc] init];
    NSError* error = nil;
    TFLInterpreter* interpreter = [[TFLInterpreter alloc]
                                    initWithModelPath:modelPath
                                              options:options
                                            delegates:@[ metalDelegate ]
                                                error:&error];
    if (error != nil) { /* Error handling... */ }

    if (![interpreter allocateTensorsWithError:&error]) { /* Error handling... */ }
    if (error != nil) { /* Error handling... */ }

    // Run inference ...

    ```
      

C (حتى 2.3.0)

    #include "tensorflow/lite/c/c_api.h"
    #include "tensorflow/lite/delegates/gpu/metal_delegate.h"

    // Initialize model
    TfLiteModel* model = TfLiteModelCreateFromFile(model_path);

    // Initialize interpreter with GPU delegate
    TfLiteInterpreterOptions* options = TfLiteInterpreterOptionsCreate();
    TfLiteDelegate* delegate = TFLGPUDelegateCreate(nil);  // default config
    TfLiteInterpreterOptionsAddDelegate(options, metal_delegate);
    TfLiteInterpreter* interpreter = TfLiteInterpreterCreate(model, options);
    TfLiteInterpreterOptionsDelete(options);

    TfLiteInterpreterAllocateTensors(interpreter);

    NSMutableData *input_data = [NSMutableData dataWithLength:input_size * sizeof(float)];
    NSMutableData *output_data = [NSMutableData dataWithLength:output_size * sizeof(float)];
    TfLiteTensor* input = TfLiteInterpreterGetInputTensor(interpreter, 0);
    const TfLiteTensor* output = TfLiteInterpreterGetOutputTensor(interpreter, 0);

    // Run inference
    TfLiteTensorCopyFromBuffer(input, inputData.bytes, inputData.length);
    TfLiteInterpreterInvoke(interpreter);
    TfLiteTensorCopyToBuffer(output, outputData.mutableBytes, outputData.length);

    // Clean up
    TfLiteInterpreterDelete(interpreter);
    TFLGpuDelegateDelete(metal_delegate);
    TfLiteModelDelete(model);
      

النماذج والعمليات المدعومة

مع إصدار مفوض GPU ، قمنا بتضمين عدد قليل من النماذج التي يمكن تشغيلها على الواجهة الخلفية:

لرؤية قائمة كاملة من العمليات المدعومة ، يرجى الاطلاع على الوثائق المتقدمة .

النماذج والعمليات غير المدعومة

إذا كانت بعض العمليات غير مدعومة من قبل مفوض GPU ، فإن إطار العمل سيعمل فقط على تشغيل جزء من الرسم البياني على GPU والجزء المتبقي على وحدة المعالجة المركزية. نظرًا للتكلفة العالية لمزامنة وحدة المعالجة المركزية / وحدة معالجة الرسومات ، فإن وضع التنفيذ المقسم مثل هذا سيؤدي غالبًا إلى أداء أبطأ مما لو كانت الشبكة بأكملها تعمل على وحدة المعالجة المركزية وحدها. في هذه الحالة ، سيتلقى المستخدم تحذيرًا مثل:

WARNING: op code #42 cannot be handled by this delegate.

لم نقدم رد اتصال لهذا الفشل ، لأن هذا ليس فشلًا حقيقيًا في وقت التشغيل ، ولكنه شيء يمكن للمطور ملاحظته أثناء محاولة تشغيل الشبكة على المفوض.

نصائح للتحسين

قد يكون لبعض العمليات البسيطة على وحدة المعالجة المركزية تكلفة عالية لوحدة معالجة الرسومات. إحدى فئات هذه العملية هي أشكال مختلفة من عمليات إعادة BATCH_TO_SPACE ، بما في ذلك BATCH_TO_SPACE و SPACE_TO_BATCH و SPACE_TO_DEPTH وما إلى ذلك. إذا تم إدخال هذه العمليات في الشبكة فقط من أجل التفكير المنطقي لمهندس الشبكة ، فإن الأمر يستحق إزالتها من أجل الأداء.

في GPU ، يتم تقسيم بيانات الموتر إلى 4 قنوات. وبالتالي ، فإن حسابًا على موتر الشكل [B,H,W,5] سيؤدي إلى نفس الأداء تقريبًا على موتر الشكل [B,H,W,8] ولكنه أسوأ بكثير من [B,H,W,4] .

بهذا المعنى ، إذا كانت أجهزة الكاميرا تدعم إطارات الصور في RGBA ، فإن تغذية المدخلات ذات 4 قنوات تكون أسرع بشكل ملحوظ حيث يمكن تجنب نسخ الذاكرة (من 3 قنوات RGB إلى 4 قنوات RGBX).

للحصول على أفضل أداء ، لا تتردد في إعادة تدريب المصنف الخاص بك باستخدام بنية شبكة مُحسّنة للجوّال. هذا جزء مهم من تحسين الاستدلال على الجهاز.