GPU Acceleration Delegat z interpretera API

Używanie jednostek przetwarzania grafiki (GPU) do uruchamiania modeli uczenia maszynowego (ML) może radykalnie poprawić wydajność i komfort korzystania z aplikacji obsługujących technologię ML. Na urządzeniach z Androidem możesz włączyć

delegata i jeden z następujących interfejsów API:

  • Interpreter API - ten przewodnik
  • API biblioteki zadań - przewodnik
  • Natywne API (C/C++) - przewodnik

Na tej stronie opisano, jak włączyć akcelerację GPU dla modeli TensorFlow Lite w aplikacjach na Androida przy użyciu interfejsu API interpretera. Aby uzyskać więcej informacji na temat korzystania z delegata procesora GPU dla TensorFlow Lite, w tym najlepszych praktyk i zaawansowanych technik, zobacz stronę delegatów procesora GPU .

Używaj procesora graficznego z TensorFlow Lite z usługami Google Play

Interfejs API interpretera TensorFlow Lite zapewnia zestaw interfejsów API ogólnego przeznaczenia do tworzenia aplikacji do uczenia maszynowego. W tej sekcji opisano, jak używać delegata akceleratora GPU z tymi interfejsami API w TensorFlow Lite z usługami Google Play.

TensorFlow Lite z usługami Google Play to zalecana ścieżka korzystania z TensorFlow Lite na Androidzie. Jeśli Twoja aplikacja jest przeznaczona dla urządzeń, na których nie działa Google Play, zobacz sekcję dotyczącą procesora graficznego z interfejsem API interpretera i samodzielnego TensorFlow Lite .

Dodaj zależności projektu

Aby umożliwić dostęp do delegata GPU, dodaj com.google.android.gms:play-services-tflite-gpu do pliku build.gradle swojej aplikacji:

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

Włącz akcelerację GPU

Następnie zainicjuj TensorFlow Lite za pomocą usług Google Play z obsługą GPU:

Kotlina

    val useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

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

Jawa

    Task useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context);

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

Możesz w końcu zainicjować interpreter przekazując GpuDelegateFactory przez InterpreterApi.Options :

Kotlina


    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)
      

Jawa


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

Delegata procesora GPU można również używać z powiązaniem modelu ML w Android Studio. Aby uzyskać więcej informacji, zobacz temat Generowanie interfejsów modelu przy użyciu metadanych .

Używaj procesora graficznego z samodzielnym TensorFlow Lite

Jeśli Twoja aplikacja jest przeznaczona dla urządzeń, na których nie działa Google Play, możliwe jest dołączenie delegata GPU do Twojej aplikacji i używanie go z samodzielną wersją TensorFlow Lite.

Dodaj zależności projektu

Aby umożliwić dostęp do delegata GPU, dodaj org.tensorflow:tensorflow-lite-gpu-delegate-plugin do pliku build.gradle swojej aplikacji:

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

Włącz akcelerację GPU

Następnie uruchom TensorFlow Lite na GPU za pomocą TfLiteDelegate . W Javie możesz określić GpuDelegate za pomocą Interpreter.Options .

Kotlina

      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)
      

Jawa

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

Modele kwantowane

Biblioteki delegatów GPU dla systemu Android domyślnie obsługują modele skwantowane. Aby używać modeli skwantowanych z delegatem procesora GPU, nie trzeba wprowadzać żadnych zmian w kodzie. W poniższej sekcji wyjaśniono, jak wyłączyć obsługę kwantyzacji do celów testowych lub eksperymentalnych.

Wyłącz obsługę modelu skwantowanego

Poniższy kod pokazuje, jak wyłączyć obsługę modeli skwantowanych.

Jawa

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

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

Aby uzyskać więcej informacji na temat uruchamiania modeli skwantowanych z akceleracją procesora GPU, zobacz Omówienie delegowania procesora GPU .