Delegato dell'accelerazione GPU con l'API Interpreter

Utilizzo delle GPU (Graphics Processing Unit) per eseguire i modelli di machine learning (ML) migliorare notevolmente le prestazioni e l'esperienza utente del tuo abilitate per ML. Sui dispositivi Android, puoi attivare un delegate e una delle seguenti API:

• Interpreter API - Questa guida
• API Native (C/C++) - guida

In questa pagina viene descritto come attivare l'accelerazione GPU per i modelli LiteRT in App per Android che utilizzano l'API Interpreter. Per ulteriori informazioni sull'uso della GPU delega per LiteRT, che comprende best practice e tecniche avanzate, consulta la pagina Delegati GPU.

Usa GPU con LiteRT con Google Play Services

L'interprete di LiteRT dell'API fornisce un insieme le API generiche per creare applicazioni di machine learning. Questa sezione descrive come utilizzare il delegato dell'acceleratore GPU con queste API con LiteRT con Google Play Services.

L'opzione LiteRT con Google Play Services è la soluzione consigliata per utilizzare LiteRT su Android. Se la tua applicazione ha come target i dispositivi non esegue Google Play, consulta la GPU con API Interpreter e la versione LiteRT.

Aggiungi dipendenze del progetto (con catalogo delle versioni .toml)

1. Aggiorna il file libs.versions.toml del progetto

[libraries]
...
tflite-gpu = { module = "com.google.ai.edge.litert:litert-gpu", version = "2.X.Y" }
tflite-gpu-api = { module = "com.google.ai.edge.litert:litert-gpu-api", version = "2.X.Y" }
...

1. Aggiungi dipendenze del progetto nel file build.gradle.kts dell'app

dependencies {
  ...
  implementation(libraries.tflite.gpu)
  implementation(libraries.tflite.gpu.api)
  ...
}

Aggiungi dipendenze del progetto

Per abilitare l'accesso al delegato GPU, aggiungi com.google.android.gms:play-services-tflite-gpu al build.gradle della tua app file:

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

Attiva l'accelerazione GPU

Quindi inizializza LiteRT con Google Play Services con il supporto GPU:

val useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

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

Task<boolean> useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context);

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

Infine puoi inizializzare l'interprete che trasmette un GpuDelegateFactory a 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);
      

Il delegato GPU può essere utilizzato anche con l'associazione del modello ML in Android Studio. Per Per ulteriori informazioni, consulta Generare interfacce del modello utilizzando metadati.

Utilizza GPU con LiteRT autonomo

Se la tua applicazione ha come target dispositivi su cui non è in esecuzione Google Play, puoi raggruppare il delegato GPU per la tua applicazione e utilizzarlo con una versione autonoma di LiteRT.

Aggiungi dipendenze del progetto

Per abilitare l'accesso al delegato GPU, aggiungi com.google.ai.edge.litert:litert-gpu-delegate-plugin per la tua app build.gradle file:

dependencies {
    ...
    implementation 'com.google.ai.edge.litert:litert'
    implementation 'com.google.ai.edge.litert:litert-gpu'
    implementation 'com.google.ai.edge.litert:litert-gpu-api'
}

Attiva l'accelerazione GPU

Poi esegui LiteRT su GPU con TfLiteDelegate. In Java, puoi specificare da GpuDelegate a 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);
      

Modelli quantificati

Le librerie delegati GPU Android supportano i modelli quantizzati per impostazione predefinita. Non devi eventuali modifiche al codice per usare modelli quantizzati con il delegato GPU. La la seguente sezione spiega come disattivare il supporto quantizzato per i test o a scopi sperimentali.

Disabilita il supporto dei modelli quantiizzati

Il seguente codice mostra come disattivare il supporto per i modelli quantizzati.

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

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

Per ulteriori informazioni sull'esecuzione di modelli quantizzati con l'accelerazione GPU, consulta Panoramica dei delegati alle GPU.