গুগল আই/ও একটি মোড়ক! TensorFlow সেশনগুলি দেখুন সেশনগুলি দেখুন

TensorFlow Lite GPU প্রতিনিধি

TensorFlow লাইট বিভিন্ন হার্ডওয়্যার ত্বরক সমর্থন করে। এই দস্তাবেজটি বর্ণনা করে যে কীভাবে Android এবং iOS-এ TensorFlow Lite প্রতিনিধি API ব্যবহার করে GPU ব্যাকএন্ড ব্যবহার করতে হয়।

GPU গুলিকে ব্যাপকভাবে সমান্তরাল কাজের চাপের জন্য উচ্চ থ্রুপুট দেওয়ার জন্য ডিজাইন করা হয়েছে। এইভাবে, এগুলি গভীর নিউরাল নেটগুলির জন্য উপযুক্ত, যার মধ্যে বিপুল সংখ্যক অপারেটর রয়েছে, প্রতিটি কিছু ইনপুট টেনসর(গুলি) এ কাজ করে যা সহজেই ছোট কাজের চাপে ভাগ করা যায় এবং সমান্তরালভাবে চালানো যায়, যার ফলে সাধারণত কম লেটেন্সি হয়। সর্বোত্তম পরিস্থিতিতে, GPU-তে অনুমান এখন আগের উপলব্ধ রিয়েল-টাইম অ্যাপ্লিকেশনগুলির জন্য যথেষ্ট দ্রুত চলতে পারে।

CPU-এর বিপরীতে, GPU গুলি 16-বিট বা 32-বিট ফ্লোটিং পয়েন্ট সংখ্যার সাথে গণনা করে এবং সর্বোত্তম কর্মক্ষমতার জন্য পরিমাপকরণের প্রয়োজন হয় না। প্রতিনিধি 8-বিট কোয়ান্টাইজড মডেলগুলি গ্রহণ করে, তবে গণনাটি ফ্লোটিং পয়েন্ট সংখ্যায় সঞ্চালিত হবে। পড়ুন উন্নত ডকুমেন্টেশন বিস্তারিত জানার জন্য।

GPU অনুমানের সাথে আরেকটি সুবিধা হল এর পাওয়ার দক্ষতা। জিপিইউগুলি অত্যন্ত দক্ষ এবং অপ্টিমাইজ করা পদ্ধতিতে গণনাগুলি সম্পাদন করে, যাতে তারা কম শক্তি খরচ করে এবং একই কাজ যখন CPU-তে চালানো হয় তার চেয়ে কম তাপ উৎপন্ন করে।

ডেমো অ্যাপ টিউটোরিয়াল

GPU প্রতিনিধি চেষ্টা করার সবচেয়ে সহজ উপায় হল নীচের টিউটোরিয়ালগুলি অনুসরণ করা, যা GPU সমর্থন সহ আমাদের শ্রেণীবিভাগ ডেমো অ্যাপ্লিকেশন তৈরি করে। GPU কোড আপাতত শুধুমাত্র বাইনারি; এটি শীঘ্রই ওপেন সোর্স করা হবে। আমাদের ডেমোগুলি কীভাবে কাজ করা যায় তা আপনি একবার বুঝে নিলে, আপনি নিজের কাস্টম মডেলগুলিতে এটি ব্যবহার করে দেখতে পারেন।

অ্যান্ড্রয়েড (অ্যান্ড্রয়েড স্টুডিও সহ)

একটি ধাপে ধাপে টিউটোরিয়ালের জন্য ঘড়ি অ্যান্ড্রয়েড জন্য GPU- প্রতিনিধি ভিডিও।

ধাপ 1. TensorFlow সোর্স কোড ক্লোন করুন এবং Android স্টুডিওতে খুলুন

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

পদক্ষেপ 2. সম্পাদনা app/build.gradle রাত্রিকালীন জিপিইউ 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 সক্ষম করার জন্য একটি বোতাম দেখতে পাবেন। কোয়ান্টাইজড থেকে একটি ফ্লোট মডেলে পরিবর্তন করুন এবং তারপর GPU-তে চালানোর জন্য GPU-তে ক্লিক করুন।

অ্যান্ড্রয়েড জিপিইউ ডেমো চালান এবং জিপিইউতে স্যুইচ করুন

iOS (XCode সহ)

একটি ধাপে ধাপে টিউটোরিয়ালের জন্য ঘড়ি iOS এর জন্য জিপিইউ প্রতিনিধি ভিডিও।

ধাপ 1. ডেমো সোর্স কোড পান এবং এটি কম্পাইল করা নিশ্চিত করুন।

আমাদের আইওএস ডেমো অ্যাপ্লিকেশান অনুসরণ টিউটোরিয়াল । এটি আপনাকে এমন একটি পয়েন্টে নিয়ে যাবে যেখানে অপরিবর্তিত iOS ক্যামেরা ডেমো আপনার ফোনে কাজ করছে।

ধাপ 2. টেনসরফ্লো লাইট জিপিইউ কোকোপড ব্যবহার করতে পডফাইল পরিবর্তন করুন

2.3.0 রিলিজ থেকে, বাইনারি আকার কমাতে ডিফল্টভাবে GPU প্রতিনিধিকে পড থেকে বাদ দেওয়া হয়। আপনি subspec উল্লেখ করে তাদের অন্তর্ভুক্ত করতে পারেন। জন্য TensorFlowLiteSwift শুঁটি:

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

বা

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

আপনার জন্য একভাবে কি করতে পারেন TensorFlowLiteObjC বা TensorFlowLitC আপনি বা C এপিআই (2.4.0 রিলিজ থেকে) উদ্দেশ্য সি ব্যবহার করতে চান।

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 প্রতিনিধি ব্যবহার করবে সক্ষম করতে, আপনাকে পরিবর্তন করতে হবে TFLITE_USE_GPU_DELEGATE 1 0 থেকে 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 প্রতিনিধি চেষ্টা করা হচ্ছে

অ্যান্ড্রয়েড

সেখানে ব্যবহার করছেন কিনা তা তার উপর নির্ভর করে মডেল ত্বরণ ডাকা করার দুটি উপায় আছে অ্যান্ড্রয়েড স্টুডিও এমএল মডেল বাঁধাই বা TensorFlow লাইট ইন্টারপ্রেটার।

টেনসরফ্লো লাইট ইন্টারপ্রেটার

কিভাবে প্রতিনিধি যোগ করতে হয় তা দেখতে ডেমো দেখুন। আপনার অ্যাপ্লিকেশনের মধ্যে, উপরে, আমদানি যেমন AAR যোগ org.tensorflow.lite.gpu.GpuDelegate মডিউল, এবং ব্যবহার addDelegate অনুবাদক করতে GPU প্রতিনিধি রেজিস্টার ফাংশন:

কোটলিন

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

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

আমরা এই ব্যর্থতার জন্য একটি কলব্যাক প্রদান করিনি, কারণ এটি একটি সত্যিকারের রান-টাইম ব্যর্থতা নয়, তবে এমন কিছু যা ডেভেলপার প্রতিনিধিদের উপর নেটওয়ার্ক চালানোর চেষ্টা করার সময় লক্ষ্য করতে পারে৷

অপ্টিমাইজেশন জন্য টিপস

মোবাইল ডিভাইসের জন্য অপ্টিমাইজ করা

CPU-তে তুচ্ছ কিছু অপারেশনের জন্য মোবাইল ডিভাইসে GPU-এর জন্য উচ্চ খরচ হতে পারে। পুনর্নির্মাণ অপারেশন বিশেষ করে চালানোর জন্য ব্যয়বহুল সহ 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) এড়ানো যেতে পারে।

সেরা পারফরম্যান্সের জন্য, আপনাকে মোবাইল-অপ্টিমাইজ করা নেটওয়ার্ক আর্কিটেকচারের সাথে ক্লাসিফায়ারকে পুনরায় প্রশিক্ষণ দেওয়ার কথা বিবেচনা করা উচিত। অন-ডিভাইস ইনফেরেন্সিংয়ের জন্য অপ্টিমাইজেশন মোবাইল হার্ডওয়্যার বৈশিষ্ট্যগুলির সুবিধা গ্রহণ করে নাটকীয়ভাবে লেটেন্সি এবং পাওয়ার খরচ কমাতে পারে।

সিরিয়ালাইজেশন সহ প্রারম্ভিক সময় হ্রাস করা

GPU ডেলিগেট বৈশিষ্ট্য আপনাকে পূর্ব-সংকলিত কার্নেল কোড থেকে লোড করতে দেয় এবং পূর্ববর্তী রান থেকে ডিস্কে ক্রমিককৃত এবং সংরক্ষিত মডেল ডেটা। এই পদ্ধতিটি পুনঃসংকলন এড়ায় এবং শুরুর সময় 90% পর্যন্ত কমিয়ে দেয়। কিভাবে আপনার প্রকল্পের ধারাবাহিকতাতে আবেদন করতে হয় তার নির্দেশাবলী জন্য, দেখুন জিপিইউ প্রতিনিধি ধারাবাহিকতাতে