Delegat i përshpejtimit të GPU-së me Interpreter API

Përdorimi i njësive të përpunimit grafik (GPU) për të ekzekutuar modelet tuaja të mësimit të makinerisë (ML) mund të përmirësojë në mënyrë dramatike performancën dhe përvojën e përdoruesit të aplikacioneve tuaja të aktivizuara me ML. Në pajisjet Android, mund të aktivizoni një delegat dhe një nga API-të e mëposhtme:

  • Interpreter API - ky udhëzues
  • API amtare (C/C++) - udhëzues

Kjo faqe përshkruan se si të aktivizoni përshpejtimin e GPU-së për modelet LiteRT në aplikacionet Android duke përdorur API-në e interpretuesit. Për më shumë informacion rreth përdorimit të delegatit të GPU për LiteRT, duke përfshirë praktikat më të mira dhe teknikat e avancuara, shihni faqen e delegatëve të GPU .

Përdorni GPU me LiteRT me shërbimet e Google Play

LiteRT Interpreter API ofron një sërë API-sh për qëllime të përgjithshme për ndërtimin e një aplikacioni për mësimin e makinerive. Ky seksion përshkruan se si të përdoret delegati i përshpejtuesit GPU me këto API me shërbimet LiteRT me Google Play.

LiteRT me shërbimet e Google Play është rruga e rekomanduar për të përdorur LiteRT në Android. Nëse aplikacioni juaj synon pajisje që nuk përdorin Google Play, shihni seksionin GPU me Interpreter API dhe seksionin e pavarur LiteRT .

Shto varësitë e projektit (me katalogun e versioneve .toml)

  1. Përditësoni skedarin libs.versions.toml të projektit tuaj 
[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. Shtoni varësitë e projektit në build.gradle.kts të aplikacionit 
dependencies {
  ...
  implementation(libs.tflite.gpu)
  implementation(libs.tflite.gpu.api)
  ...
}

Shtoni varësitë e projektit

Për të aktivizuar aksesin te delegati i GPU-së, shtoni com.google.android.gms:play-services-tflite-gpu në skedarin build.gradle të aplikacionit tuaj:

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

Aktivizo përshpejtimin e GPU-së

Më pas inicializoni LiteRT me shërbimet e Google Play me mbështetjen e GPU:

Kotlin 

val useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

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

Java 

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

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

Më në fund mund të inicializoni përkthyesin duke kaluar një GpuDelegateFactory përmes InterpreterApi.Options :

Kotlin 

    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)

Java 

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

Delegati i GPU-së mund të përdoret gjithashtu me lidhjen e modelit ML në Android Studio. Për më shumë informacion, shihni Krijo ndërfaqe modeli duke përdorur metadatat .

Përdorni GPU me LiteRT të pavarur

Nëse aplikacioni juaj synon pajisje që nuk ekzekutojnë Google Play, është e mundur të bashkoni delegatin e GPU-së në aplikacionin tuaj dhe ta përdorni atë me versionin e pavarur të LiteRT.

Shtoni varësitë e projektit

Për të aktivizuar aksesin te delegati i GPU-së, shtoni com.google.ai.edge.litert:litert-gpu-delegate-plugin në skedarin build.gradle të aplikacionit tuaj:

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

Aktivizo përshpejtimin e GPU-së

Pastaj ekzekutoni LiteRT në GPU me TfLiteDelegate . Në Java, mund të specifikoni GpuDelegate përmes 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)

Java 

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

Modele të kuantizuara

Bibliotekat e delegatëve të GPU-së Android mbështesin modelet e kuantizuara si parazgjedhje. Ju nuk keni nevojë të bëni ndonjë ndryshim kodi për të përdorur modele të kuantizuara me delegatin e GPU. Seksioni vijues shpjegon se si të çaktivizohet mbështetja e kuantizuar për qëllime testimi ose eksperimentale.

Çaktivizo mbështetjen e modelit të kuantizuar

Kodi i mëposhtëm tregon se si të çaktivizoni mbështetjen për modelet e kuantizuara.

Java 

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

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

Për më shumë informacion rreth ekzekutimit të modeleve të kuantizuara me përshpejtim GPU, shihni përmbledhjen e delegatëve të GPU .