Delegat akceleracji GPU dla Androida

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Używanie jednostek przetwarzania grafiki (GPU) do uruchamiania modeli uczenia maszynowego (ML) może znacznie poprawić wydajność modelu i wrażenia użytkownika aplikacji obsługujących ML. Na urządzeniach z systemem Android możesz włączyć akcelerowane przez GPU wykonywanie modeli za pomocą delegata . Delegaci działają jako sterowniki sprzętowe dla TensorFlow Lite, umożliwiając uruchamianie kodu modelu na procesorach GPU.

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

Użyj GPU z interfejsami API biblioteki zadań

Biblioteki zadań TensorFlow Lite zapewniają zestaw interfejsów API specyficznych dla zadań do tworzenia aplikacji uczenia maszynowego. W tej sekcji opisano, jak używać delegata akceleratora GPU z tymi interfejsami API.

Dodaj zależności projektu

Włącz dostęp do interfejsów API delegatów GPU za pomocą bibliotek zadań TensorFlow Lite, dodając następujące zależności, zaktualizuj plik build.gradle projektów deweloperskich, aby uwzględnić tensorflow-lite-gpu-delegate-plugin , jak pokazano w poniższym przykładzie kodu:

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

Włącz akcelerację GPU

Włącz opcję delegata GPU dla klasy modelu interfejsu API zadań z klasą BaseOptions . Na przykład możesz skonfigurować GPU w ObjectDetector , jak pokazano w następujących przykładach kodu:

Kotlin

    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)

      

Jawa

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

Użyj procesora graficznego z interfejsem API interpretera

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

Dodaj zależności projektu

Włącz dostęp do interfejsów API delegata GPU, dodając następujące zależności, zaktualizuj plik build.gradle projektów deweloperskich, aby uwzględnić org.tensorflow:tensorflow-lite-gpu , jak pokazano w poniższym przykładzie kodu:

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

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 .

Kotlin

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

Delegat GPU może być również używany z powiązaniem modelu ML w Android Studio. Więcej informacji zawiera sekcja Generowanie interfejsów modelu przy użyciu metadanych .

Zaawansowana obsługa GPU

W tej sekcji omówiono zaawansowane zastosowania delegata GPU dla systemu Android, w tym interfejs API C, interfejs API C++ i użycie modeli kwantowych.

C/C++ API dla Androida

Użyj delegata GPU TensorFlow Lite dla systemu Android w języku C lub C++, tworząc delegata za pomocą TfLiteGpuDelegateV2Create() i niszcząc go za pomocą TfLiteGpuDelegateV2Delete() , jak pokazano w poniższym przykładowym kodzie:

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

Zapoznaj się z kodem obiektu TfLiteGpuDelegateOptionsV2 , aby utworzyć wystąpienie delegata z opcjami niestandardowymi. Możesz zainicjować domyślne opcje za pomocą TfLiteGpuDelegateOptionsV2Default() , a następnie zmodyfikować je w razie potrzeby.

Delegat TensorFlow Lite GPU dla Androida w C lub C++ używa systemu kompilacji Bazel . Delegata można zbudować za pomocą następującego polecenia:

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

Podczas wywoływania Interpreter::ModifyGraphWithDelegate() lub Interpreter::Invoke() , wywołujący musi mieć EGLContext w bieżącym wątku, a Interpreter::Invoke() musi być wywołany z tego samego EGLContext . Jeśli EGLContext nie istnieje, delegat tworzy go wewnętrznie, ale musisz upewnić się, że Interpreter::Invoke() jest zawsze wywoływany z tego samego wątku, w którym Interpreter::ModifyGraphWithDelegate() .

Modele skwantowane

Biblioteki delegatów GPU systemu Android domyślnie obsługują modele kwantowane. Nie musisz wprowadzać żadnych zmian w kodzie, aby używać modeli skwantyzowanych z delegatem GPU. Poniższa sekcja wyjaśnia, jak wyłączyć obsługę kwantową do celów testowych lub eksperymentalnych.

Wyłącz obsługę modeli skwantowanych

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

C++

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

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

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