Delegado de aceleración GPU para Android

El uso de unidades de procesamiento de gráficos (GPU) para ejecutar sus modelos de aprendizaje automático (ML) puede mejorar drásticamente el rendimiento de su modelo y la experiencia del usuario de sus aplicaciones habilitadas para ML. En los dispositivos Android, puede habilitar el uso de la ejecución acelerada por GPU de sus modelos mediante un delegado . Los delegados actúan como controladores de hardware para TensorFlow Lite, lo que le permite ejecutar el código de su modelo en procesadores GPU.

Esta página describe cómo habilitar la aceleración de GPU para los modelos TensorFlow Lite en las aplicaciones de Android. Para obtener más información sobre el uso del delegado de GPU para TensorFlow Lite, incluidas las prácticas recomendadas y las técnicas avanzadas, consulte la página de delegados de GPU .

Usar GPU con las API de la biblioteca de tareas

Las bibliotecas de tareas de TensorFlow Lite proporcionan un conjunto de API específicas de tareas para crear aplicaciones de aprendizaje automático. Esta sección describe cómo usar el delegado del acelerador de GPU con estas API.

Agregar dependencias del proyecto

Habilite el acceso a las API delegadas de GPU con las bibliotecas de tareas de TensorFlow Lite agregando las siguientes dependencias, actualice el archivo build.gradle de sus proyectos de desarrollo para incluir el tensorflow-lite-gpu-delegate-plugin como se muestra en el siguiente código de ejemplo:

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

Habilitar la aceleración de GPU

Habilite la opción de delegado de GPU para su clase de modelo de API de tareas con la clase BaseOptions . Por ejemplo, puede configurar GPU en ObjectDetector como se muestra en los siguientes ejemplos de código:

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

Usar GPU con API de intérprete

La API de intérprete de TensorFlow Lite proporciona un conjunto de API de uso general para crear aplicaciones de aprendizaje automático. Esta sección describe cómo usar el delegado del acelerador de GPU con estas API.

Agregar dependencias del proyecto

Habilite el acceso a las API delegadas de GPU agregando las siguientes dependencias, actualice el archivo build.gradle de sus proyectos de desarrollo para incluir el org.tensorflow:tensorflow-lite-gpu como se muestra en el siguiente código de ejemplo:

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

Habilitar la aceleración de GPU

Luego ejecute TensorFlow Lite en GPU con TfLiteDelegate . En Java, puede especificar el GpuDelegate a través de 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);
      

El delegado de GPU también se puede usar con el enlace de modelos ML en Android Studio. Para obtener más información, consulte Generar interfaces de modelo mediante metadatos .

Compatibilidad con GPU avanzada

Esta sección cubre los usos avanzados del delegado de GPU para Android, incluida la API de C, la API de C++ y el uso de modelos cuantificados.

API de C/C++ para Android

Usa el delegado GPU de TensorFlow Lite para Android en C o C++ creando el delegado con TfLiteGpuDelegateV2Create() y destruyéndolo con TfLiteGpuDelegateV2Delete() , como se muestra en el siguiente código de ejemplo:

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

Revise el código de objeto TfLiteGpuDelegateOptionsV2 para crear una instancia de delegado con opciones personalizadas. Puede inicializar las opciones predeterminadas con TfLiteGpuDelegateOptionsV2Default() y luego modificarlas según sea necesario.

El delegado de GPU TensorFlow Lite para Android en C o C++ usa el sistema de compilación Bazel . Puede construir el delegado usando el siguiente comando:

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

Al llamar a Interpreter::ModifyGraphWithDelegate() o Interpreter::Invoke() , la persona que llama debe tener un EGLContext en el subproceso actual e Interpreter::Invoke() debe llamarse desde el mismo EGLContext . Si no existe un EGLContext , el delegado crea uno internamente, pero luego debe asegurarse de que Interpreter::Invoke() siempre se llame desde el mismo subproceso en el que se llamó a Interpreter::ModifyGraphWithDelegate() .

modelos cuantificados

Las bibliotecas de delegados de GPU de Android admiten modelos cuantificados de forma predeterminada. No tiene que realizar ningún cambio de código para usar modelos cuantificados con el delegado de GPU. La siguiente sección explica cómo deshabilitar el soporte cuantificado para fines de prueba o experimentales.

Deshabilitar el soporte de modelo cuantificado

El siguiente código muestra cómo deshabilitar la compatibilidad con modelos cuantificados.

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;
      

Para obtener más información sobre cómo ejecutar modelos cuantificados con aceleración de GPU, consulte Información general sobre delegados de GPU .