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 .