Gjeneroni ndërfaqe modeli duke përdorur metadata

Duke përdorur LiteRT Metadata , zhvilluesit mund të gjenerojnë kodin e mbështjellësit për të mundësuar integrimin në Android. Për shumicën e zhvilluesve, ndërfaqja grafike e Android Studio ML Model Binding është më e lehta për t'u përdorur. Nëse keni nevojë për më shumë personalizim ose jeni duke përdorur veglat e linjës së komandës, LiteRT Codegen është gjithashtu i disponueshëm.

Përdor Android Studio ML Model Binding

Për modelet LiteRT të përmirësuara me metadata , zhvilluesit mund të përdorin Android Studio ML Model Binding për të konfiguruar automatikisht cilësimet për projektin dhe për të gjeneruar klasa mbështjellëse bazuar në meta të dhënat e modelit. Kodi i mbështjellësit heq nevojën për të bashkëvepruar drejtpërdrejt me ByteBuffer . Në vend të kësaj, zhvilluesit mund të ndërveprojnë me modelin LiteRT me objekte të shtypura si Bitmap dhe Rect .

Importoni një model LiteRT në Android Studio

  1. Klikoni me të djathtën në modulin që dëshironi të përdorni modelin TFLite ose klikoni mbi File , pastaj New > Other > LiteRT Model

  2. Zgjidhni vendndodhjen e skedarit tuaj TFLite. Vini re se vegla do të konfigurojë varësinë e modulit në emrin tuaj me lidhjen e Modelit ML dhe të gjitha varësitë e futura automatikisht në skedarin build.gradle të modulit tuaj Android.

    Opsionale: Zgjidhni kutinë e dytë të zgjedhjes për importimin e TensorFlow GPU nëse dëshironi të përdorni përshpejtimin e GPU.

  3. Klikoni Finish .

  4. Ekrani i mëposhtëm do të shfaqet pasi importimi të jetë i suksesshëm. Për të filluar përdorimin e modelit, zgjidhni Kotlin ose Java, kopjoni dhe ngjisni kodin nën seksionin Sample Code . Mund të ktheheni në këtë ekran duke klikuar dy herë modelin TFLite nën drejtorinë ml në Android Studio.

Përshpejtimi i përfundimit të modelit

Lidhja e modelit ML ofron një mënyrë për zhvilluesit që të përshpejtojnë kodin e tyre përmes përdorimit të delegatëve dhe numrit të thread-ve.

Hapi 1. Kontrolloni skedarin build.gradle të modulit që ai përmban varësinë e mëposhtme:

    dependencies {
        ...
        // TFLite GPU delegate 2.3.0 or above is required.
        implementation 'com.google.ai.edge.litert:litert-gpu:2.3.0'
    }

Hapi 2. Zbuloni nëse GPU që funksionon në pajisje është e përputhshme me delegatin e GPU-së TensorFlow, nëse nuk ekzekutohet modeli duke përdorur fije të shumta CPU:

Kotlin 

    import org.tensorflow.lite.gpu.CompatibilityList
    import org.tensorflow.lite.gpu.GpuDelegate

    val compatList = CompatibilityList()

    val options = if(compatList.isDelegateSupportedOnThisDevice) {
        // if the device has a supported GPU, add the GPU delegate
        Model.Options.Builder().setDevice(Model.Device.GPU).build()
    } else {
        // if the GPU is not supported, run on 4 threads
        Model.Options.Builder().setNumThreads(4).build()
    }

    // Initialize the model as usual feeding in the options object
    val myModel = MyModel.newInstance(context, options)

    // Run inference per sample code

Java 

    import org.tensorflow.lite.support.model.Model
    import org.tensorflow.lite.gpu.CompatibilityList;
    import org.tensorflow.lite.gpu.GpuDelegate;

    // Initialize interpreter with GPU delegate
    Model.Options options;
    CompatibilityList compatList = CompatibilityList();

    if(compatList.isDelegateSupportedOnThisDevice()){
        // if the device has a supported GPU, add the GPU delegate
        options = Model.Options.Builder().setDevice(Model.Device.GPU).build();
    } else {
        // if the GPU is not supported, run on 4 threads
        options = Model.Options.Builder().setNumThreads(4).build();
    }

    MyModel myModel = new MyModel.newInstance(context, options);

    // Run inference per sample code

Gjeneroni ndërfaqe modeli me gjeneratorin e kodit LiteRT

Për modelin LiteRT të përmirësuar me metadata , zhvilluesit mund të përdorin gjeneratorin e kodit të mbështjellësit të LiteRT Android për të krijuar kodin e mbështjellësit specifik të platformës. Kodi i mbështjellësit heq nevojën për të bashkëvepruar drejtpërdrejt me ByteBuffer . Në vend të kësaj, zhvilluesit mund të ndërveprojnë me modelin TensorFlow Lite me objekte të shtypura si Bitmap dhe Rect .

Dobia e gjeneratorit të kodit varet nga plotësia e hyrjes së meta të dhënave të modelit LiteRT. Referojuni seksionit <Codegen usage> nën fushat përkatëse në metadata_schema.fbs , për të parë se si mjeti i kodegjenit analizon secilën fushë.

Gjeneroni kodin e mbështjellësit

Ju do të duhet të instaloni veglat e mëposhtme në terminalin tuaj:

pip install tflite-support

Pasi të përfundojë, gjeneruesi i kodit mund të përdoret duke përdorur sintaksën e mëposhtme:

tflite_codegen --model=./model_with_metadata/mobilenet_v1_0.75_160_quantized.tflite \
    --package_name=org.tensorflow.lite.classify \
    --model_class_name=MyClassifierModel \
    --destination=./classify_wrapper

Kodi që rezulton do të gjendet në drejtorinë e destinacionit. Nëse jeni duke përdorur Google Colab ose një mjedis tjetër të largët, mund të jetë më e lehtë të zipni rezultatin në një arkiv zip dhe ta shkarkoni në projektin tuaj Android Studio:

# Zip up the generated code
!zip -r classify_wrapper.zip classify_wrapper/

# Download the archive
from google.colab import files
files.download('classify_wrapper.zip')

Duke përdorur kodin e krijuar

Hapi 1: Importoni kodin e krijuar

Shpalosni kodin e krijuar nëse është e nevojshme në një strukturë drejtorie. Rrënja e kodit të gjeneruar supozohet të jetë SRC_ROOT .

Hapni projektin Android Studio ku dëshironi të përdorni modelin LiteRT dhe importoni modulin e gjeneruar nga: Dhe File -> I Ri -> Import Module -> zgjidhni SRC_ROOT

Duke përdorur shembullin e mësipërm, drejtoria dhe moduli i importuar do të quheshin classify_wrapper .

Hapi 2: Përditësoni skedarin build.gradle të aplikacionit

Në modulin e aplikacionit që do të konsumojë modulin e krijuar të bibliotekës:

Nën seksionin android, shtoni sa vijon:

aaptOptions {
   noCompress "tflite"
}

Nën seksionin e varësive, shtoni sa vijon:

implementation project(":classify_wrapper")

Hapi 3: Përdorimi i modelit 

// 1. Initialize the model
MyClassifierModel myImageClassifier = null;

try {
    myImageClassifier = new MyClassifierModel(this);
} catch (IOException io){
    // Error reading the model
}

if(null != myImageClassifier) {

    // 2. Set the input with a Bitmap called inputBitmap
    MyClassifierModel.Inputs inputs = myImageClassifier.createInputs();
    inputs.loadImage(inputBitmap));

    // 3. Run the model
    MyClassifierModel.Outputs outputs = myImageClassifier.run(inputs);

    // 4. Retrieve the result
    Map<String, Float> labeledProbability = outputs.getProbability();
}

Përshpejtimi i përfundimit të modelit

Kodi i gjeneruar ofron një mënyrë për zhvilluesit që të përshpejtojnë kodin e tyre përmes përdorimit të delegatëve dhe numrit të temave. Këto mund të vendosen gjatë inicializimit të objektit të modelit pasi kërkon tre parametra:

  • Context : Konteksti nga Aktiviteti ose Shërbimi i Android
  • (Opsionale) Device : delegat i përshpejtimit TFLite. Për shembull: GPUDelegate
  • (Opsionale) numThreads : Numri i thread-ve të përdorur për të ekzekutuar modelin - e paracaktuar është një.

Për shembull, për të përdorur një delegat GPU dhe deri në tre threads, mund ta inicializoni modelin si kjo: 

try {
    myImageClassifier = new MyClassifierModel(this, Model.Device.GPU, 3);
} catch (IOException io){
    // Error reading the model
}

Zgjidhja e problemeve

Nëse merrni një 'java.io.FileNotFoundException: Ky skedar nuk mund të hapet si përshkrues skedari; ndoshta është gabim i ngjeshur, futni rreshtat e mëposhtëm nën seksionin android të modulit të aplikacionit që do të përdorë modulin e bibliotekës: 

aaptOptions {
   noCompress "tflite"
}