TensorFlow Lite GPU प्रतिनिधि

TensorFlow Lite कई हार्डवेयर एक्सेलेरेटर का समर्थन करता है। यह दस्तावेज़ वर्णन करता है कि Android और iOS पर TensorFlow Lite प्रतिनिधि API का उपयोग करके GPU बैकएंड का उपयोग कैसे करें।

GPU को बड़े पैमाने पर समानांतर वर्कलोड के लिए उच्च थ्रूपुट के लिए डिज़ाइन किया गया है। इस प्रकार, वे गहरे तंत्रिका जाल के लिए अच्छी तरह से अनुकूल हैं, जिसमें बड़ी संख्या में ऑपरेटर होते हैं, प्रत्येक कुछ इनपुट टेंसर (ओं) पर काम करते हैं जिन्हें आसानी से छोटे वर्कलोड में विभाजित किया जा सकता है और समानांतर में किया जा सकता है, जिसके परिणामस्वरूप आमतौर पर कम विलंबता होती है। सबसे अच्छे परिदृश्य में, GPU पर अनुमान अब पहले से उपलब्ध वास्तविक समय के अनुप्रयोगों के लिए पर्याप्त तेजी से चल सकता है।

सीपीयू के विपरीत, जीपीयू 16-बिट या 32-बिट फ्लोटिंग पॉइंट नंबरों के साथ गणना करते हैं और इष्टतम प्रदर्शन के लिए परिमाणीकरण की आवश्यकता नहीं होती है। प्रतिनिधि 8-बिट मात्रात्मक मॉडल स्वीकार करता है, लेकिन गणना फ़्लोटिंग पॉइंट नंबरों में की जाएगी। विवरण के लिए उन्नत दस्तावेज़ीकरण देखें।

GPU अनुमान के साथ एक और लाभ इसकी शक्ति दक्षता है। जीपीयू बहुत ही कुशल और अनुकूलित तरीके से गणना करते हैं, ताकि वे कम बिजली की खपत करें और सीपीयू पर एक ही कार्य चलाने की तुलना में कम गर्मी उत्पन्न करें।

डेमो ऐप ट्यूटोरियल

GPU प्रतिनिधि को आज़माने का सबसे आसान तरीका नीचे दिए गए ट्यूटोरियल का अनुसरण करना है, जो GPU समर्थन के साथ हमारे वर्गीकरण डेमो एप्लिकेशन का निर्माण करते हैं। अभी के लिए GPU कोड केवल बाइनरी है; इसे जल्द ही ओपन-सोर्स किया जाएगा। एक बार जब आप समझ जाते हैं कि हमारे डेमो को कैसे काम करना है, तो आप इसे अपने स्वयं के कस्टम मॉडल पर आज़मा सकते हैं।

एंड्रॉइड (एंड्रॉइड स्टूडियो के साथ)

चरण-दर-चरण ट्यूटोरियल के लिए, Android वीडियो के लिए GPU प्रतिनिधि देखें।

चरण 1. TensorFlow स्रोत कोड को क्लोन करें और इसे Android Studio में खोलें

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

चरण 2. रात्रिकालीन GPU AAR का उपयोग करने के लिए app/build.gradle संपादित करें

मौजूदा dependencies ब्लॉक में मौजूदा tensorflow-lite पैकेज के साथ tensorflow-lite-gpu पैकेज जोड़ें।

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

चरण 3. बनाएं और चलाएं

रन → रन 'ऐप'। जब आप एप्लिकेशन चलाते हैं तो आपको GPU सक्षम करने के लिए एक बटन दिखाई देगा। परिमाणित से फ्लोट मॉडल में बदलें और फिर GPU पर चलने के लिए GPU पर क्लिक करें।

एंड्रॉइड जीपीयू डेमो चला रहा है और जीपीयू पर स्विच करें

आईओएस (एक्सकोड के साथ)

चरण-दर-चरण ट्यूटोरियल के लिए, iOS वीडियो के लिए GPU प्रतिनिधि देखें।

चरण 1. डेमो स्रोत कोड प्राप्त करें और सुनिश्चित करें कि यह संकलित है।

हमारे आईओएस डेमो ऐप ट्यूटोरियल का पालन करें। यह आपको उस बिंदु पर ले जाएगा जहां आपके फोन पर अनमोडिफाइड आईओएस कैमरा डेमो काम कर रहा है।

चरण 2. TensorFlow Lite GPU CocoaPod का उपयोग करने के लिए पॉडफाइल को संशोधित करें

2.3.0 रिलीज से, डिफ़ॉल्ट रूप से GPU प्रतिनिधि को बाइनरी आकार को कम करने के लिए पॉड से बाहर रखा गया है। आप सबस्पेक निर्दिष्ट करके उन्हें शामिल कर सकते हैं। TensorFlowLiteSwift पॉड के लिए:

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

या

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

यदि आप Objective-C (2.4.0 रिलीज़ से) या C API का उपयोग करना चाहते हैं, तो आप TensorFlowLiteObjC या TensorFlowLitC के लिए भी ऐसा ही कर सकते हैं।

2.3.0 रिलीज से पहले

TensorFlow Lite 2.0.0 . तक

हमने एक बाइनरी CocoaPod बनाया है जिसमें GPU प्रतिनिधि शामिल है। प्रोजेक्ट को इसका उपयोग करने के लिए स्विच करने के लिए, `टेन्सरफ़्लो/टेंसरफ़्लो/लाइट/उदाहरण/आईओएस/कैमरा/पॉडफ़ाइल` फ़ाइल को `टेन्सरफ़्लोलाइट` के बजाय `टेन्सरफ़्लोलाइटजीपीयूएक्सपेरिमेंटल` पॉड का उपयोग करने के लिए संशोधित करें।


    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 प्रतिनिधि का उपयोग करने वाले कोड को सक्षम करने के लिए, आपको CameraExampleViewController.h में 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 मॉडल बाइंडिंग या TensorFlow लाइट इंटरप्रेटर का उपयोग कर रहे हैं, तो इस पर निर्भर करते हुए मॉडल त्वरण को लागू करने के दो तरीके हैं।

TensorFlow लाइट दुभाषिया

प्रतिनिधि को जोड़ने का तरीका देखने के लिए डेमो देखें। अपने आवेदन में, ऊपर के रूप में AAR जोड़ें, org.tensorflow.lite.gpu.GpuDelegate मॉड्यूल आयात करें, और GPU प्रतिनिधि को दुभाषिया में पंजीकृत करने के लिए addDelegate फ़ंक्शन का उपयोग करें:

Kotlin

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

आईओएस

तीव्र

    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 ...

        ```
          

सी (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);
          

## Supported Models and Ops

With the release of the GPU delegate, we included a handful of models that can
be run on the backend:

*   [MobileNet v1 (224x224) image classification](https://ai.googleblog.com/2017/06/mobilenets-open-source-models-for.html) [[download]](https://storage.googleapis.com/download.tensorflow.org/models/tflite/gpu/mobilenet_v1_1.0_224.tflite)
    <br /><i>(image classification model designed for mobile and embedded based vision applications)</i>
*   [DeepLab segmentation (257x257)](https://ai.googleblog.com/2018/03/semantic-image-segmentation-with.html) [[download]](https://storage.googleapis.com/download.tensorflow.org/models/tflite/gpu/deeplabv3_257_mv_gpu.tflite)
    <br /><i>(image segmentation model that assigns semantic labels (e.g., dog, cat, car) to every pixel in the input image)</i>
*   [MobileNet SSD object detection](https://ai.googleblog.com/2018/07/accelerated-training-and-inference-with.html) [[download]](https://storage.googleapis.com/download.tensorflow.org/models/tflite/gpu/mobile_ssd_v2_float_coco.tflite)
    <br /><i>(image classification model that detects multiple objects with bounding boxes)</i>
*   [PoseNet for pose estimation](https://github.com/tensorflow/tfjs-models/tree/master/posenet) [[download]](https://storage.googleapis.com/download.tensorflow.org/models/tflite/gpu/multi_person_mobilenet_v1_075_float.tflite)
    <br /><i>(vision model that estimates the poses of a person(s) in image or video)</i>

To see a full list of supported ops, please see the
[advanced documentation](gpu_advanced).

## Non-supported models and ops

If some of the ops are not supported by the GPU delegate, the framework will
only run a part of the graph on the GPU and the remaining part on the CPU. Due
to the high cost of CPU/GPU synchronization, a split execution mode like this
will often result in slower performance than when the whole network is run on
the CPU alone. In this case, the user will get a warning like:

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

हमने इस विफलता के लिए कॉलबैक प्रदान नहीं किया, क्योंकि यह एक वास्तविक रन-टाइम विफलता नहीं है, लेकिन कुछ ऐसा है जिसे डेवलपर प्रतिनिधि पर नेटवर्क चलाने की कोशिश करते समय देख सकता है।

अनुकूलन के लिए युक्तियाँ

मोबाइल उपकरणों के लिए अनुकूलन

कुछ ऑपरेशन जो सीपीयू पर तुच्छ हैं, मोबाइल उपकरणों पर जीपीयू के लिए उच्च लागत हो सकती है। BATCH_TO_SPACE , SPACE_TO_BATCH , SPACE_TO_DEPTH , इत्यादि सहित BATCH_TO_SPACE ऑपरेशन चलाना विशेष रूप से महंगा है। आपको रीशेप ऑपरेशंस के उपयोग की बारीकी से जांच करनी चाहिए, और विचार करना चाहिए कि इसे केवल डेटा की खोज के लिए या आपके मॉडल के शुरुआती पुनरावृत्तियों के लिए लागू किया गया हो। उन्हें हटाने से प्रदर्शन में काफी सुधार हो सकता है।

GPU पर, टेंसर डेटा को 4-चैनलों में विभाजित किया जाता है। इस प्रकार, आकार के एक टेंसर पर एक गणना [B,H,W,5] आकार के एक टेंसर पर समान प्रदर्शन करेगी [B,H,W,8] लेकिन [B,H,W,4] से काफी खराब है। . उस अर्थ में, यदि कैमरा हार्डवेयर आरजीबीए में छवि फ्रेम का समर्थन करता है, तो उस 4-चैनल इनपुट को खिलाने से मेमोरी कॉपी (3-चैनल आरजीबी से 4-चैनल आरजीबीएक्स तक) से बचा जा सकता है।

सर्वोत्तम प्रदर्शन के लिए, आपको मोबाइल-अनुकूलित नेटवर्क आर्किटेक्चर के साथ क्लासिफायरियर को फिर से प्रशिक्षित करने पर विचार करना चाहिए। ऑन-डिवाइस अनुमान के लिए अनुकूलन मोबाइल हार्डवेयर सुविधाओं का लाभ उठाकर विलंबता और बिजली की खपत को नाटकीय रूप से कम कर सकता है।

क्रमांकन के साथ आरंभीकरण समय को कम करना

GPU प्रतिनिधि सुविधा आपको पूर्व-संकलित कर्नेल कोड से लोड करने की अनुमति देती है और मॉडल डेटा को क्रमबद्ध और पिछले रन से डिस्क पर सहेजा जाता है। यह दृष्टिकोण पुन: संकलन से बचाता है और स्टार्टअप समय को 90% तक कम करता है। अपने प्रोजेक्ट में क्रमांकन कैसे लागू करें, इस पर निर्देशों के लिए, GPU प्रतिनिधि क्रमांकन देखें।