Delegasi akselerasi GPU dengan Interpreter API

Menggunakan unit pemrosesan grafis (GPU) untuk menjalankan model pembelajaran mesin (ML) dapat meningkatkan performa dan pengalaman pengguna aplikasi Anda yang mendukung ML secara signifikan. Di perangkat Android, Anda dapat mengaktifkan

delegasi dan salah satu API berikut:

• API Juru Bahasa - panduan ini
• API perpustakaan tugas - panduan
• API Asli (C/C++) - panduan

Halaman ini menjelaskan cara mengaktifkan akselerasi GPU untuk model TensorFlow Lite di aplikasi Android menggunakan Interpreter API. Untuk informasi selengkapnya tentang penggunaan delegasi GPU untuk TensorFlow Lite, termasuk praktik terbaik dan teknik lanjutan, lihat halaman delegasi GPU .

Gunakan GPU dengan TensorFlow Lite dengan layanan Google Play

TensorFlow Lite Interpreter API menyediakan serangkaian API tujuan umum untuk membangun aplikasi pembelajaran mesin. Bagian ini menjelaskan cara menggunakan delegasi akselerator GPU dengan API ini dengan TensorFlow Lite dengan layanan Google Play.

TensorFlow Lite dengan layanan Google Play adalah jalur yang disarankan untuk menggunakan TensorFlow Lite di Android. Jika aplikasi Anda menargetkan perangkat yang tidak menjalankan Google Play, lihat bagian GPU dengan Interpreter API dan TensorFlow Lite mandiri .

Tambahkan dependensi proyek

Untuk mengaktifkan akses ke delegasi GPU, tambahkan com.google.android.gms:play-services-tflite-gpu ke file build.gradle aplikasi Anda:

dependencies {
    ...
    implementation 'com.google.android.gms:play-services-tflite-java:16.0.1'
    implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
}

Aktifkan akselerasi GPU

Kemudian inisialisasi TensorFlow Lite dengan layanan Google Play dengan dukungan GPU:

    val useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

    val interpreterTask = useGpuTask.continueWith { useGpuTask ->
      TfLite.initialize(context,
          TfLiteInitializationOptions.builder()
          .setEnableGpuDelegateSupport(useGpuTask.result)
          .build())
      }
      

    Task useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context);

    Task interpreterOptionsTask = useGpuTask.continueWith({ task ->
      TfLite.initialize(context,
      TfLiteInitializationOptions.builder()
        .setEnableGpuDelegateSupport(true)
        .build());
    });
      

Anda akhirnya dapat menginisialisasi penerjemah dengan meneruskan GpuDelegateFactory melalui InterpreterApi.Options :

    val options = InterpreterApi.Options()
      .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
      .addDelegateFactory(GpuDelegateFactory())

    val interpreter = InterpreterApi(model, options)

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

    Options options = InterpreterApi.Options()
      .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
      .addDelegateFactory(new GpuDelegateFactory());

    Interpreter interpreter = new InterpreterApi(model, options);

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

Delegasi GPU juga dapat digunakan dengan pengikatan model ML di Android Studio. Untuk informasi selengkapnya, lihat Menghasilkan antarmuka model menggunakan metadata .

Gunakan GPU dengan TensorFlow Lite mandiri

Jika aplikasi Anda menargetkan perangkat yang tidak menjalankan Google Play, delegasi GPU dapat digabungkan ke aplikasi Anda dan menggunakannya dengan TensorFlow Lite versi mandiri.

Tambahkan dependensi proyek

Untuk mengaktifkan akses ke delegasi GPU, tambahkan org.tensorflow:tensorflow-lite-gpu-delegate-plugin ke file build.gradle aplikasi Anda:

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

Aktifkan akselerasi GPU

Kemudian jalankan TensorFlow Lite pada GPU dengan TfLiteDelegate . Di Java, Anda dapat menentukan GpuDelegate melalui Interpreter.Options .

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

Model terkuantisasi

Library delegasi GPU Android mendukung model terkuantisasi secara default. Anda tidak perlu melakukan perubahan kode apa pun untuk menggunakan model terkuantisasi dengan delegasi GPU. Bagian berikut menjelaskan cara menonaktifkan dukungan terkuantisasi untuk tujuan pengujian atau eksperimental.

Nonaktifkan dukungan model terkuantisasi

Kode berikut menunjukkan cara menonaktifkan dukungan untuk model terkuantisasi.

GpuDelegate delegate = new GpuDelegate(new GpuDelegate.Options().setQuantizedModelsAllowed(false));

Interpreter.Options options = (new Interpreter.Options()).addDelegate(delegate);
      

Untuk informasi selengkapnya tentang menjalankan model terkuantisasi dengan akselerasi GPU, lihat Ikhtisar delegasi GPU .