日付を保存! Google I / Oが5月18日から20日に戻ってきます今すぐ登録
このページは Cloud Translation API によって翻訳されました。
Switch to English

TensorFlow LiteGPUデリゲート

TensorFlow Liteは、いくつかのハードウェアアクセラレータをサポートしています。このドキュメントでは、AndroidおよびiOSでTensorFlowLiteデリゲートAPIを使用してGPUバックエンドを使用する方法について説明します。

GPUは、大規模に並列化可能なワークロードに対して高スループットを実現するように設計されています。したがって、これらは、多数の演算子で構成されるディープニューラルネットに最適です。各演算子は、小さなワークロードに簡単に分割して並列に実行できる入力テンソルで動作し、通常はレイテンシが低くなります。最良のシナリオでは、GPUでの推論は、以前は利用できなかったリアルタイムアプリケーションに対して十分に高速に実行される可能性があります。

CPUとは異なり、GPUは16ビットまたは32ビットの浮動小数点数で計算し、最適なパフォーマンスを得るために量子化を必要としません。デリゲートは8ビットの量子化モデルを受け入れますが、計算は浮動小数点数で実行されます。詳細については、高度なドキュメントを参照してください。

GPU推論のもう1つの利点は、電力効率です。 GPUは、非常に効率的で最適化された方法で計算を実行するため、同じタスクがCPUで実行される場合よりも、消費電力と発熱量が少なくなります。

デモアプリのチュートリアル

GPUデリゲートを試す最も簡単な方法は、GPUをサポートする分類デモアプリケーションの構築を行う以下のチュートリアルに従うことです。 GPUコードは今のところバイナリのみです。間もなくオープンソースになります。デモを機能させる方法を理解したら、独自のカスタムモデルでこれを試すことができます。

Android(Android Studioを使用)

ステップバイステップのチュートリアルについては、Android用GPUデリゲートのビデオをご覧ください。

手順1.TensorFlowソースコードのクローンを作成し、AndroidStudioで開きます

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

ステップapp/build.gradleを編集して、夜間のapp/build.gradleを使用します

tensorflow-lite-gpuパッケージを、既存のdependenciesブロックの既存のtensorflow-liteパッケージと一緒に追加します。

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

ステップ3.ビルドして実行する

実行→「アプリ」を実行します。アプリケーションを実行すると、GPUを有効にするためのボタンが表示されます。量子化モデルからフロートモデルに変更し、[GPU]をクリックしてGPUで実行します。

android gpuデモを実行し、gpuに切り替えます

iOS(XCode付き)

ステップバイステップのチュートリアルについては、iOS用GPUデリゲートのビデオをご覧ください

手順1.デモソースコードを入手して、コンパイルされることを確認します。

iOSデモアプリのチュートリアルに従ってください。これにより、変更されていないiOSカメラのデモが携帯電話で機能するようになります。

手順2.TensorFlow Lite GPUCocoaPodを使用するようにPodfileを変更します

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 Lite2.0.0まで

GPUデリゲートを含むバイナリCocoaPodを構築しました。プロジェクトを使用するように切り替えるには、 `tensorflow / tensorflow / lite / examples / ios / camera / Podfile`ファイルを変更して` TensorFlowLite`の代わりに `TensorFlowLiteGpuExperimental`ポッドを使用します。


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

TensorFlow Lite2.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選択しRun 。 [ Info ]タブで、[ Build Configuration ]を[ Debugから[ Release ]に変更し、[ Debug executableチェックを外しDebug executable

リリースの設定

次に、[ Options ]タブをクリックし、[ GPU Frame Capture ]を[ Disabled ]に、[ Metal API Validation ]を[ Disabled ]に変更しDisabled

金属オプションの設定

最後に、64ビットアーキテクチャでのリリースのみのビルドを選択してください。 Project navigator -> tflite_camera_example -> PROJECT -> tflite_camera_example -> Build Settings Build Active Architecture Only > ReleaseをYesに設定します。

リリースオプションの設定

独自のモデルでGPUデリゲートを試す

アンドロイド

Android StudioMLモデルバインディングとTensorFlowLiteインタープリターのどちらを使用しているかに応じて、モデルアクセラレーションを呼び出す方法は2つあります。

TensorFlowLiteインタープリター

デモを見て、デリゲートを追加する方法を確認してください。アプリケーションで、上記のようにAARを追加し、 org.tensorflow.lite.gpu.GpuDelegateモジュールをインポートし、 addDelegate関数を使用してGPUデリゲートをインタープリターに登録します。

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)
      

Java

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

Objective-C

    // 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で実行し、残りの部分はCPUで実行します。 CPU / GPU同期のコストが高いため、このような分割実行モードでは、ネットワーク全体をCPUのみで実行する場合よりもパフォーマンスが低下することがよくあります。この場合、ユーザーは次のような警告を受け取ります。

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

これは実際の実行時の障害ではなく、開発者がデリゲートでネットワークを実行しようとしているときに観察できるものであるため、この障害のコールバックは提供しませんでした。

最適化のヒント

CPUで簡単な操作の中には、GPUのコストが高くなるものがあります。このような動作の一つのクラスは、以下を含む変形操作の様々な形態でBATCH_TO_SPACESPACE_TO_BATCHSPACE_TO_DEPTHなど、および。これらの操作がネットワークアーキテクトの論理的思考のためだけにネットワークに挿入されている場合は、パフォーマンスのためにそれらを削除する価値があります。

GPUでは、テンソルデータは4チャネルにスライスされます。したがって、形状[B,H,W,5]テンソルの計算は、形状[B,H,W,8]テンソルでほぼ同じように実行されますが、 [B,H,W,4]よりも大幅に劣り[B,H,W,4]

その意味で、カメラハードウェアがRGBAの画像フレームをサポートしている場合、メモリコピー(3チャンネルRGBから4チャンネルRGBXへ)を回避できるため、その4チャンネル入力のフィードは大幅に高速になります。

最高のパフォーマンスを得るには、モバイル向けに最適化されたネットワークアーキテクチャで分類器を再トレーニングすることを躊躇しないでください。これは、デバイス上の推論の最適化の重要な部分です。