Gjeneroni ndërfaqe modeli duke përdorur metadata

Duke përdorur LiteRT Metadata , zhvilluesit mund të gjenerojnë kod mbështjellës 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 lehtë për t’u përdorur. Nëse keni nevojë për më shumë personalizim ose po përdorni mjete të linjës së komandës, LiteRT Codegen është gjithashtu i disponueshëm.

Përdorni lidhjen e modelit ML të Android Studio

Për modelet LiteRT të përmirësuara me meta të dhëna , 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 mbështjellës eliminon nevojën për të bashkëvepruar drejtpërdrejt me ByteBuffer . Në vend të kësaj, zhvilluesit mund të bashkëveprojnë me modelin LiteRT me objekte të tipizuara si Bitmap dhe Rect .

Importoni një model LiteRT në Android Studio

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

  2. Zgjidhni vendndodhjen e skedarit tuaj TFLite. Vini re se mjetet do të konfigurojnë varësinë e modulit në emrin tuaj me lidhjen e modelit ML dhe të gjitha varësitë do të futen automatikisht në skedarin build.gradle të modulit tuaj Android.

    Opsionale: Zgjidhni kutinë e dytë të kontrollit për importimin e GPU-së TensorFlow nëse doni të përdorni përshpejtimin e GPU-së.

  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 direktorinë ml në Android Studio.

Përshpejtimi i nxjerrjes së përfundimeve të modelit

Lidhja e Modelit ML u ofron zhvilluesve një mënyrë për të përshpejtuar kodin e tyre përmes përdorimit të delegatëve dhe numrit të fijeve.

Hapi 1. Kontrolloni që skedari i modulit build.gradle të përmbajë varësinë e mëposhtme:

    dependencies {
        ...
        // For the LiteRT GPU delegate, we need
        // 'com.google.ai.edge.litert:litert-gpu' version 1.*.
        implementation 'com.google.ai.edge.litert:litert-gpu:1.4.1'
    }

Hapi 2. Zbuloni nëse GPU-ja që funksionon në pajisje është e pajtueshme me delegatin e GPU-së TensorFlow, nëse jo, ekzekutoni modelin duke përdorur fije të shumëfishta të CPU-së:

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 meta të dhëna , zhvilluesit mund të përdorin gjeneratorin e kodit të mbështjellësit LiteRT për Android për të krijuar kod mbështjellësi specifik për platformën. Kodi i mbështjellësit eliminon nevojën për të bashkëvepruar drejtpërdrejt me ByteBuffer . Në vend të kësaj, zhvilluesit mund të bashkëveprojnë me modelin TensorFlow Lite me objekte të tipizuara 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 gjeneratorit të kodit e analizon secilën fushë.

Gjeneroni Kodin e Mbështjellësit

Do të duhet të instaloni mjetet e mëposhtme në terminalin tuaj:

pip install tflite-support

Pasi të përfundojë, gjeneratori 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ë vendoset në direktorinë e destinacionit. Nëse përdorni Google Colab ose ndonjë mjedis tjetër të largët, ndoshta është më e lehtë ta ziponi 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 gjeneruar

Hapi 1: Importoni kodin e gjeneruar

Nëse është e nevojshme, çkompresoni kodin e gjeneruar në një strukturë direktorie. 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 duke përdorur: Dhe Skedar -> I Ri -> Import Modul -> zgjidhni SRC_ROOT

Duke përdorur shembullin e mësipërm, direktoria 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 bibliotekës së gjeneruar:

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 nxjerrjes së përfundimeve të modelit

Kodi i gjeneruar u ofron zhvilluesve një mënyrë për të përshpejtuar kodin e tyre përmes përdorimit të delegatëve dhe numrit të fijeve. Këto mund të caktohen gjatë inicializimit të objektit të modelit pasi ai merr tre parametra:

  • Context : Konteksti nga Aktiviteti ose Shërbimi i Android
  • (Opsionale) Device : Delegati i përshpejtimit TFLite. Për shembull: GPUDelegate
  • (Opsionale) numThreads : Numri i fijeve të përdorura për të ekzekutuar modelin - parazgjedhja është një.

Për shembull, për të përdorur një delegat GPU dhe deri në tre fije, 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 shfaqet gabimi 'java.io.FileNotFoundException: Ky skedar nuk mund të hapet si përshkrues skedari; ndoshta është i kompresuar', 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"
}