LiteRT në API të shërbimeve të Google Play Java (dhe Kotlin).

LiteRT në shërbimet e Google Play mund të aksesohet gjithashtu duke përdorur API-të Java, të cilat mund të përdoren nga kodi Java ose Kotlin, përveç API-së vendase. Në veçanti, LiteRT në shërbimet e Google Play është i disponueshëm përmes LiteRT Interpreter API .

Përdorimi i API-ve të interpretuesit

LiteRT Interpreter API, i ofruar nga koha e funksionimit TensorFlow, ofron një ndërfaqe me qëllime të përgjithshme për ndërtimin dhe ekzekutimin e modeleve ML. Përdorni hapat e mëposhtëm për të ekzekutuar konkluzionet me API-në e interpretuesit duke përdorur TensorFlow Lite në kohën e ekzekutimit të shërbimeve të Google Play.

1. Shtoni varësitë e projektit

Shtoni varësitë e mëposhtme në kodin e projektit të aplikacionit tuaj për të hyrë në API të shërbimeve të Play për LiteRT:

dependencies {
...
    // LiteRT dependencies for Google Play services
    implementation 'com.google.android.gms:play-services-tflite-java:16.1.0'
    // Optional: include LiteRT Support Library
    implementation 'com.google.android.gms:play-services-tflite-support:16.1.0'
...
}

2. Shto inicializimin e LiteRT

Inicializoni komponentin LiteRT të API-së së shërbimeve të Google Play përpara se të përdorni API-të LiteRT:

val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }

Task<Void> initializeTask = TfLite.initialize(context);

3. Krijoni një Interpreter dhe vendosni opsionin e kohës së funksionimit

Krijoni një përkthyes duke përdorur InterpreterApi.create() dhe konfiguroni atë për të përdorur kohën e ekzekutimit të shërbimeve të Google Play, duke thirrur InterpreterApi.Options.setRuntime() , siç tregohet në kodin e shembullit të mëposhtëm:

import org.tensorflow.lite.InterpreterApi
import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime
...
private lateinit var interpreter: InterpreterApi
...
initializeTask.addOnSuccessListener {
  val interpreterOption =
    InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  interpreter = InterpreterApi.create(
    modelBuffer,
    interpreterOption
  )}
  .addOnFailureListener { e ->
    Log.e("Interpreter", "Cannot initialize interpreter", e)
  }

import org.tensorflow.lite.InterpreterApi
import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime
...
private InterpreterApi interpreter;
...
initializeTask.addOnSuccessListener(a -> {
    interpreter = InterpreterApi.create(modelBuffer,
      new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY));
  })
  .addOnFailureListener(e -> {
    Log.e("Interpreter", String.format("Cannot initialize interpreter: %s",
          e.getMessage()));
  });

Duhet të përdorni implementimin e mësipërm sepse shmang bllokimin e lidhjes së ndërfaqes së përdoruesit Android. Nëse keni nevojë të menaxhoni më nga afër ekzekutimin e thread-it, mund të shtoni një thirrje Tasks.await() në krijimin e përkthyesit:

import androidx.lifecycle.lifecycleScope
...
lifecycleScope.launchWhenStarted { // uses coroutine
  initializeTask.await()
}

@BackgroundThread
InterpreterApi initializeInterpreter() {
    Tasks.await(initializeTask);
    return InterpreterApi.create(...);
}

4. Drejtoni konkluzionet

Duke përdorur objektin interpreter që keni krijuar, thirrni metodën run() për të gjeneruar një përfundim.

interpreter.run(inputBuffer, outputBuffer)

interpreter.run(inputBuffer, outputBuffer);

Përshpejtimi i harduerit

LiteRT ju lejon të përshpejtoni performancën e modelit tuaj duke përdorur procesorë të specializuar harduerësh, të tillë si njësitë e përpunimit grafik (GPU). Ju mund të përfitoni nga këta procesorë të specializuar duke përdorur drejtues harduerësh të quajtur delegatë .

Delegati i GPU-së ofrohet përmes shërbimeve të Google Play dhe ngarkohet në mënyrë dinamike, ashtu si versionet e shërbimeve të Play të Interpreter API.

Kontrollimi i përputhshmërisë së pajisjes

Jo të gjitha pajisjet mbështesin përshpejtimin e harduerit GPU me TFLite. Për të zbutur gabimet dhe dështimet e mundshme, përdorni metodën TfLiteGpu.isGpuDelegateAvailable për të kontrolluar nëse një pajisje është e përputhshme me delegatin e GPU.

Përdorni këtë metodë për të konfirmuar nëse një pajisje është e përputhshme me GPU dhe përdorni CPU-në si rezervë kur GPU nuk mbështetet.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Pasi të keni një variabël si useGpuTask , mund ta përdorni për të përcaktuar nëse pajisjet përdorin delegatin GPU.

val interpreterTask = useGpuTask.continueWith { task ->
  val interpreterOptions = InterpreterApi.Options()
      .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  if (task.result) {
      interpreterOptions.addDelegateFactory(GpuDelegateFactory())
  }
  InterpreterApi.create(FileUtil.loadMappedFile(context, MODEL_PATH), interpreterOptions)
}
    

Task<InterpreterApi.Options> interpreterOptionsTask = useGpuTask.continueWith({ task ->
  InterpreterApi.Options options =
      new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY);
  if (task.getResult()) {
     options.addDelegateFactory(new GpuDelegateFactory());
  }
  return options;
});
    

GPU me Interpreter API

Për të përdorur delegatin e GPU me API-të e interpretuesit:

1. Përditësoni varësitë e projektit për të përdorur delegatin e GPU-së nga shërbimet e Play:

   implementation 'com.google.android.gms:play-services-tflite-gpu:16.2.0'
   

2. Aktivizo opsionin e delegimit të GPU në inicializimin TFlite:

   Kotlin

   TfLite.initialize(context,
     TfLiteInitializationOptions.builder()
       .setEnableGpuDelegateSupport(true)
       .build())

   Java

   TfLite.initialize(context,
     TfLiteInitializationOptions.builder()
       .setEnableGpuDelegateSupport(true)
       .build());

3. Aktivizo delegatin e GPU-së në opsionet e përkthyesit: vendosni fabrikën e delegimit në GpuDelegateFactory duke thirrur addDelegateFactory() within InterpreterApi.Options()`:

   Kotlin

   val interpreterOption = InterpreterApi.Options()
     .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
     .addDelegateFactory(GpuDelegateFactory())

   Java

   Options interpreterOption = InterpreterApi.Options()
     .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
     .addDelegateFactory(new GpuDelegateFactory());

Migrimi nga LiteRT i pavarur

Nëse po planifikoni të migroni aplikacionin tuaj nga LiteRT i pavarur në API të shërbimeve të Play, rishikoni udhëzimet shtesë të mëposhtme për përditësimin e kodit të projektit të aplikacionit tuaj:

1. Rishikoni seksionin e Kufizimeve të kësaj faqeje për t'u siguruar që rasti juaj i përdorimit mbështetet.
2. Përpara se të përditësoni kodin tuaj, ju rekomandojmë të bëni kontrolle të performancës dhe saktësisë për modelet tuaja, veçanërisht nëse përdorni versione të LiteRT (TF Lite) më të hershme se versioni 2.1, kështu që keni një bazë për të krahasuar me zbatimin e ri.
3. Nëse e keni migruar të gjithë kodin tuaj për të përdorur API-në e shërbimeve të Play për LiteRT, duhet të hiqni varësitë ekzistuese të bibliotekës së kohës së funksionimit LiteRT (hyrjet me org.tensorflow: tensorflow-lite :* ) nga skedari juaj build.gradle në mënyrë që të mund të zvogëloni madhësinë e aplikacionit tuaj.
4. Identifikoni të gjitha ndodhitë e krijimit të objektit new Interpreter në kodin tuaj dhe modifikoni secilën në mënyrë që të përdorë thirrjen InterpreterApi.create() . TfLite.initialize i ri është asinkron, që do të thotë se në shumicën e rasteve nuk është një zëvendësim i lëshuar: duhet të regjistroni një dëgjues kur telefonata të përfundojë. Referojuni pjesës së kodit në kodin e hapit 3 .
5. Shto import org.tensorflow.lite.InterpreterApi; dhe import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; te çdo skedar burimi duke përdorur klasat org.tensorflow.lite.Interpreter ose org.tensorflow.lite.InterpreterApi .
6. Nëse ndonjë nga thirrjet që rezultojnë në InterpreterApi.create() ka vetëm një argument të vetëm, shtojini new InterpreterApi.Options() në listën e argumenteve.
7. Shtoni .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) në argumentin e fundit të çdo thirrjeje në InterpreterApi.create() .
8. Zëvendësoni të gjitha dukuritë e tjera të klasës org.tensorflow.lite.Interpreter me org.tensorflow.lite.InterpreterApi .

Nëse dëshironi të përdorni LiteRT të pavarur dhe API-në e shërbimeve të Play krah për krah, duhet të përdorni versionin 2.9 të LiteRT (TF Lite) ose më të ri. Versioni 2.8 i LiteRT (TF Lite) dhe versionet e mëparshme nuk janë në përputhje me versionin e API të shërbimeve të Play.