Bu sayfa, Cloud Translation API ile çevrilmiştir.
Switch to English

TensorFlow Lite GPU temsilcisi

TensorFlow Lite birkaç donanım hızlandırıcıyı destekler. Bu belge, Android ve iOS'ta TensorFlow Lite delege API'leri kullanılarak GPU arka ucunun nasıl kullanılacağını açıklar.

GPU'lar, büyük ölçüde paralelleştirilebilir iş yükleri için yüksek verim sağlayacak şekilde tasarlanmıştır. Bu nedenle, çok sayıda operatörden oluşan derin sinir ağları için çok uygundurlar, her biri kolayca daha küçük iş yüklerine bölünebilen ve paralel olarak gerçekleştirilebilen bazı giriş tensör (ler) i üzerinde çalışır ve tipik olarak daha düşük gecikme süresi sağlar. En iyi senaryoda, GPU üzerindeki çıkarım artık önceden mevcut olmayan gerçek zamanlı uygulamalar için yeterince hızlı çalışabilir.

CPU'lardan farklı olarak, GPU'lar 16-bit veya 32-bit kayan nokta sayılarıyla hesaplar ve optimum performans için niceleme gerektirmez. Temsilci, 8 bitlik nicemlenmiş modelleri kabul etmez, ancak hesaplama kayan noktalı sayılarda gerçekleştirilecektir. Ayrıntılar için gelişmiş belgelere bakın.

GPU çıkarımının bir başka yararı da güç verimliliğidir. GPU'lar, hesaplamaları çok verimli ve optimize edilmiş bir şekilde gerçekleştirir, böylece daha az güç tüketirler ve aynı görev CPU'larda çalıştırıldığında olduğundan daha az ısı üretirler.

Demo uygulama eğitimleri

GPU temsilcisini denemenin en kolay yolu, sınıflandırma demo uygulamalarımızı GPU desteğiyle oluşturmanın üzerinden geçen aşağıdaki eğitimleri takip etmektir. GPU kodu şimdilik yalnızca ikili; yakında açık kaynaklı olacak. Demolarımızı nasıl çalıştıracağınızı anladıktan sonra, bunu kendi özel modelleriniz üzerinde deneyebilirsiniz.

Android (Android Studio ile)

Adım adım eğitim için Android için GPU Temsilcisi videosunu izleyin.

Adım 1. TensorFlow kaynak kodunu klonlayın ve Android Studio'da açın

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

Adım 2. Gecelik GPU app/build.gradle kullanmak için app/build.gradle düzenleyin

Mevcut dependencies bloğundaki mevcut tensorflow-lite paketinin yanına tensorflow-lite-gpu paketini tensorflow-lite .

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

Adım 3. Oluşturun ve çalıştırın

Çalıştır → 'Uygulamayı' çalıştırın. Uygulamayı çalıştırdığınızda, GPU'yu etkinleştirmek için bir düğme göreceksiniz. Niceliklendirilmiş modelden hareketli modele geçin ve ardından GPU'da çalıştırmak için GPU'ya tıklayın.

android gpu demosunu çalıştırma ve gpu'ya geçme

iOS (XCode ile)

Adım adım eğitim için iOS için GPU Delegate videosunu izleyin.

Adım 1. Demo kaynak kodunu alın ve derlendiğinden emin olun.

İOS Demo Uygulama eğitimimizi takip edin. Bu sizi, değiştirilmemiş iOS kamera demosunun telefonunuzda çalıştığı bir noktaya götürür.

Adım 2. TensorFlow Lite GPU CocoaPod'u kullanmak için Pod dosyasını değiştirin

TensorFlow Lite 2.0.0'a kadar GPU temsilcisini içeren ikili bir CocoaPod oluşturduk. Projeyi kullanmak üzere değiştirmek için, "tensorflow / tensorflow / lite / samples / ios / camera / Podfile" dosyasını "TensorFlowLite" yerine "TensorFlowLiteGpuExperimental" bölmesini kullanacak şekilde değiştirin. "'ProjenizinAdı' # bölmesini hedefleyin 'TensorFlowLite', '1.12.0' kapsülü 'TensorFlowLiteGpuExperimental' ''

TensorFlow Lite 2.1.0'dan, GPU temsilcisi TensorFlowLiteC bölmesine dahildir. TensorFlowLiteSwift bağlı olarak TensorFlowLiteC ve TensorFlowLiteSwift arasında seçim yapabilirsiniz.

Gecelik sürüm ve gelecek 2.3.0 sürümü için, varsayılan olarak GPU delegesi ikili boyutu azaltmak için kapsülden çıkarılır. Alt tür belirterek bunları dahil edebilirsiniz. TensorFlowLiteSwift bölmesi için:

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

VEYA

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

C API'sini kullanmak istiyorsanız TensorFlowLiteC için benzer şekilde yapabilirsiniz.

Adım 3. GPU temsilcisini etkinleştirin

GPU temsilcisini kullanacak kodu etkinleştirmek için, CameraExampleViewController.h TFLITE_USE_GPU_DELEGATE 0'dan 1'e değiştirmeniz gerekir.

#define TFLITE_USE_GPU_DELEGATE 1

Adım 4. Demo uygulamasını oluşturun ve çalıştırın

Önceki adımı izledikten sonra, uygulamayı çalıştırabilmeniz gerekir.

Adım 5. Serbest bırakma modu

4. Adımda hata ayıklama modunda çalışırken, daha iyi performans elde etmek için, uygun optimum Metal ayarlarıyla bir sürüm yapısına geçmelisiniz. Özellikle, bu ayarları düzenlemek için Product > Scheme > Edit Scheme... seçeneğine gidin. Run seçin. On Info sekmesi, değişim Build Configuration dan, Debug için Release işaretini kaldırın Debug executable .

sürüm kurma

Ardından Options sekmesini tıklayın ve GPU Frame Capture Disabled ve Metal API Validation Disabled .

metal seçenekleri ayarlamak

Son olarak, 64 bit mimaride Yalnızca yayın sürümlerini seçtiğinizden emin olun. Project navigator -> tflite_camera_example -> PROJECT -> tflite_camera_example -> Build Settings Build Active Architecture Only > Release seçeneğini Yes olarak ayarlayın.

sürüm seçeneklerini ayarlama

GPU temsilcisini kendi modelinizde denemek

Android

Android Studio ML Model Binding veya TensorFlow Lite Interpreter kullanıyor olmanıza bağlı olarak model hızlandırmayı çağırmanın iki yolu vardır.

TensorFlow Lite Yorumlayıcı

Temsilciyi nasıl ekleyeceğinizi görmek için demoya bakın. Uygulamanızda, org.tensorflow.lite.gpu.GpuDelegate yukarıdaki gibi ekleyin, org.tensorflow.lite.gpu.GpuDelegate modülünü içe org.tensorflow.lite.gpu.GpuDelegate ve GPU temsilcisini yorumlayıcıya kaydetmek için addDelegate işlevini kullanın:

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

Swift

GPU temsilcisi ile TensorFlow Lite yorumlayıcısını başlatın.

import TensorFlowLite

// Load model ...

let delegate = MetalDelegate()

if let interpreter = try Interpreter(modelPath: modelPath,
                                     delegates: [delegate]) {
  // Run inference ...
}

Amaç-C

Uygulama kodunuza GPU temsilci başlığını dahil edin ve GPU temsilcisini yorumlayıcıya kaydetmek için Interpreter::ModifyGraphWithDelegate işlevini Interpreter::ModifyGraphWithDelegate :

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

Desteklenen Modeller ve Ops

GPU temsilcisinin piyasaya sürülmesiyle, arka uçta çalıştırılabilen birkaç model ekledik:

Desteklenen işlemlerin tam listesini görmek için lütfen gelişmiş belgelere bakın .

Desteklenmeyen modeller ve operasyonlar

İşlemlerden bazıları GPU temsilcisi tarafından desteklenmiyorsa, çerçeve yalnızca GPU'da grafiğin bir bölümünü ve CPU'da kalan kısmını çalıştırır. CPU / GPU senkronizasyonunun yüksek maliyeti nedeniyle, bunun gibi bir bölünmüş yürütme modu genellikle tüm ağın yalnızca CPU üzerinde çalıştırılmasına göre daha yavaş performansa neden olur. Bu durumda, kullanıcı aşağıdaki gibi bir uyarı alır:

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

Bu hata için bir geri arama sağlamadık, çünkü bu gerçek bir çalışma zamanı hatası değil, ancak geliştiricinin ağı temsilci üzerinde çalıştırmaya çalışırken gözlemleyebileceği bir şey.

Optimizasyon için ipuçları

CPU üzerinde önemsiz olan bazı işlemlerin GPU için yüksek bir maliyeti olabilir. Bu tür işlemlerin bir sınıfı, BATCH_TO_SPACE , SPACE_TO_BATCH , SPACE_TO_DEPTH ve benzerleri dahil olmak üzere çeşitli yeniden şekillendirme işlemleri biçimleridir. Bu operasyonlar ağa yalnızca ağ mimarının mantıksal düşüncesi için eklenmişse, performans için onları kaldırmaya değer.

GPU'da tensör verileri 4 kanala bölünür. Bu durumda, şekilli bir tensör bir hesaplama [B,H,W,5] bir şeklin tensör ile yaklaşık olarak aynı gerçekleştirecek [B,H,W,8] , ancak daha kötü [B,H,W,4] .

Bu anlamda, kamera donanımı RGBA'daki görüntü çerçevelerini destekliyorsa, bu 4 kanallı girişi beslemek, bellek kopyası (3 kanallı RGB'den 4 kanallı RGBX'e) önlenebileceği için önemli ölçüde daha hızlıdır.

En iyi performans için, sınıflandırıcınızı mobil cihazlar için optimize edilmiş bir ağ mimarisiyle yeniden eğitmekten çekinmeyin. Bu, cihaz üzerinde çıkarım için optimizasyonun önemli bir parçasıdır.