Delegato di accelerazione GPU per Android

L'utilizzo di unità di elaborazione grafica (GPU) per eseguire i modelli di machine learning (ML) può migliorare notevolmente le prestazioni del modello e l'esperienza utente delle applicazioni abilitate per ML. Sui dispositivi Android, puoi abilitare l'uso dell'esecuzione con accelerazione GPU dei tuoi modelli utilizzando un delegato . I delegati fungono da driver hardware per TensorFlow Lite, consentendoti di eseguire il codice del tuo modello su processori GPU.

Questa pagina descrive come abilitare l'accelerazione GPU per i modelli TensorFlow Lite nelle app Android. Per ulteriori informazioni sull'utilizzo del delegato GPU per TensorFlow Lite, comprese le best practice e le tecniche avanzate, vedere la pagina dei delegati GPU .

Usa la GPU con le API della libreria delle attività

Le librerie di attività di TensorFlow Lite forniscono una serie di API specifiche per attività per la creazione di applicazioni di machine learning. Questa sezione descrive come utilizzare il delegato dell'acceleratore GPU con queste API.

Aggiungi le dipendenze del progetto

Consenti l'accesso alle API delegate della GPU con le librerie di attività TensorFlow Lite aggiungendo le seguenti dipendenze, aggiorna il file build.gradle dei progetti di sviluppo per includere il tensorflow-lite-gpu-delegate-plugin come mostrato nell'esempio di codice seguente:

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

Abilita accelerazione GPU

Abilita l'opzione del delegato GPU per la classe del modello dell'API Task con la classe BaseOptions . Ad esempio, puoi configurare la GPU in ObjectDetector come mostrato nei seguenti esempi di codice:

    import org.tensorflow.lite.task.core.BaseOptions
    import org.tensorflow.lite.task.gms.vision.detector.ObjectDetector

    val baseOptions = BaseOptions.builder().useGpu().build()

    val options =
        ObjectDetector.ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build()

    val objectDetector = ObjectDetector.createFromFileAndOptions(
      context, model, options)

      

    import org.tensorflow.lite.task.core.BaseOptions
    import org.tensorflow.lite.task.gms.vision.detector.ObjectDetector

    BaseOptions baseOptions = BaseOptions.builder().useGpu().build();

    ObjectDetectorOptions options =
        ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build();

    val objectDetector = ObjectDetector.createFromFileAndOptions(
      context, model, options);
      

Usa la GPU con l'API interprete

L' API dell'interprete TensorFlow Lite fornisce una serie di API generiche per la creazione di applicazioni di machine learning. Questa sezione descrive come utilizzare il delegato dell'acceleratore GPU con queste API.

Aggiungi le dipendenze del progetto

Consenti l'accesso alle API delegate della GPU aggiungendo le seguenti dipendenze, aggiorna il file build.gradle dei tuoi progetti di sviluppo per includere il org.tensorflow:tensorflow-lite-gpu come mostrato nel seguente esempio di codice:

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

Abilita accelerazione GPU

Quindi esegui TensorFlow Lite su GPU con TfLiteDelegate . In Java, puoi specificare GpuDelegate tramite 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);
      

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

Supporto GPU avanzato

Questa sezione illustra gli usi avanzati del delegato GPU per Android, tra cui l'API C, l'API C++ e l'uso di modelli quantizzati.

API C/C++ per Android

Utilizzare il delegato GPU TensorFlow Lite per Android in C o C++ creando il delegato con TfLiteGpuDelegateV2Create() e distruggendolo con TfLiteGpuDelegateV2Delete() , come mostrato nel codice di esempio seguente:

// Set up interpreter.
auto model = FlatBufferModel::BuildFromFile(model_path);
if (!model) return false;
ops::builtin::BuiltinOpResolver op_resolver;
std::unique_ptr<Interpreter> interpreter;
InterpreterBuilder(*model, op_resolver)(&interpreter);

// NEW: Prepare GPU delegate.
auto* delegate = TfLiteGpuDelegateV2Create(/*default options=*/nullptr);
if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;

// Run inference.
WriteToInputTensor(interpreter->typed_input_tensor<float>(0));
if (interpreter->Invoke() != kTfLiteOk) return false;
ReadFromOutputTensor(interpreter->typed_output_tensor<float>(0));

// NEW: Clean up.
TfLiteGpuDelegateV2Delete(delegate);

Esaminare il codice oggetto TfLiteGpuDelegateOptionsV2 per creare un'istanza delegato con opzioni personalizzate. È possibile inizializzare le opzioni predefinite con TfLiteGpuDelegateOptionsV2Default() e quindi modificarle secondo necessità.

Il delegato GPU TensorFlow Lite per Android in C o C++ utilizza il sistema di build Bazel . È possibile creare il delegato utilizzando il comando seguente:

bazel build -c opt --config android_arm64 tensorflow/lite/delegates/gpu:delegate                           # for static library
bazel build -c opt --config android_arm64 tensorflow/lite/delegates/gpu:libtensorflowlite_gpu_delegate.so  # for dynamic library

Quando si chiama Interpreter::ModifyGraphWithDelegate() o Interpreter::Invoke() , il chiamante deve avere un EGLContext nel thread corrente e Interpreter::Invoke() deve essere chiamato dallo stesso EGLContext . Se un EGLContext non esiste, il delegato ne crea uno internamente, ma è necessario assicurarsi che Interpreter::Invoke() venga sempre chiamato dallo stesso thread in cui è stato chiamato Interpreter::ModifyGraphWithDelegate() .

Modelli quantizzati

Le librerie dei delegati GPU Android supportano i modelli quantizzati per impostazione predefinita. Non è necessario apportare modifiche al codice per utilizzare i modelli quantizzati con il delegato GPU. La sezione seguente spiega come disabilitare il supporto quantizzato per scopi di test o sperimentali.

Disabilita il supporto del modello quantizzato

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

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

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

TfLiteGpuDelegateOptionsV2 options = TfLiteGpuDelegateOptionsV2Default();
options.experimental_flags = TFLITE_GPU_EXPERIMENTAL_FLAGS_NONE;

auto* delegate = TfLiteGpuDelegateV2Create(options);
if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;
      

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