Genera interfacce del modello utilizzando i metadati

Utilizzando LiteRT Metadata, gli sviluppatori possono generare codice wrapper per abilitare l'integrazione su Android. Per la maggior parte degli sviluppatori, l'interfaccia grafica di Android Studio ML Model Binding è la più facile da usare. Se hai bisogno di una maggiore personalizzazione o utilizzi strumenti a riga di comando, è disponibile anche LiteRT Codegen.

Utilizzare il binding del modello ML di Android Studio

Per i modelli LiteRT migliorati con i metadati, gli sviluppatori possono utilizzare Android Studio ML Model Binding per configurare automaticamente le impostazioni del progetto e generare classi wrapper in base ai metadati del modello. Il codice wrapper elimina la necessità di interagire direttamente con ByteBuffer. Gli sviluppatori possono invece interagire con il modello LiteRT con oggetti tipizzati come Bitmap e Rect.

Importare un modello LiteRT in Android Studio

  1. Fai clic con il tasto destro del mouse sul modulo in cui vuoi utilizzare il modello TFLite o fai clic su File, poi su New > Other > LiteRT Model.

  2. Seleziona la posizione del file TFLite. Tieni presente che gli strumenti configureranno la dipendenza del modulo per tuo conto con il binding del modello ML e tutte le dipendenze verranno inserite automaticamente nel file build.gradle del modulo Android.

    (Facoltativo) Seleziona la seconda casella di controllo per importare TensorFlow GPU se vuoi utilizzare l'accelerazione GPU.

  3. Fai clic su Finish.

  4. Dopo l'importazione, viene visualizzata la seguente schermata. Per iniziare a utilizzare il modello, seleziona Kotlin o Java, copia e incolla il codice nella sezione Sample Code. Puoi tornare a questa schermata facendo doppio clic sul modello TFLite nella directory ml di Android Studio.

Accelerare l'inferenza del modello

Il binding del modello ML consente agli sviluppatori di accelerare il codice tramite l'utilizzo di delegati e del numero di thread.

Passaggio 1: Controlla il file del modulo build.gradle per verificare che contenga la seguente dipendenza:

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

Passaggio 2: Rileva se la GPU in esecuzione sul dispositivo è compatibile con il delegato GPU TensorFlow, in caso contrario esegui il modello utilizzando più thread della 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

Generare interfacce del modello con il generatore di codice LiteRT

Per il modello LiteRT migliorato con metadati, gli sviluppatori possono utilizzare il generatore di codice wrapper Android LiteRT per creare codice wrapper specifico per la piattaforma. Il codice wrapper elimina la necessità di interagire direttamente con ByteBuffer. Gli sviluppatori possono invece interagire con il modello TensorFlow Lite con oggetti tipizzati come Bitmap e Rect.

L'utilità del generatore di codice dipende dalla completezza della voce di metadati del modello LiteRT. Consulta la sezione <Codegen usage> nei campi pertinenti di metadata_schema.fbs per scoprire come lo strumento di generazione del codice analizza ogni campo.

Genera codice wrapper

Dovrai installare i seguenti strumenti nel terminale:

pip install tflite-support

Una volta completato, il generatore di codici può essere utilizzato con la seguente sintassi:

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

Il codice risultante si troverà nella directory di destinazione. Se utilizzi Google Colab o un altro ambiente remoto, potrebbe essere più facile comprimere il risultato in un archivio zip e scaricarlo nel progetto 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')

Utilizzo del codice generato

Passaggio 1: importa il codice generato

Decomprimi il codice generato, se necessario, in una struttura di directory. La radice del codice generato è SRC_ROOT.

Apri il progetto Android Studio in cui vuoi utilizzare il modello LiteRT e importa il modulo generato tramite File -> Nuovo -> Importa modulo -> seleziona SRC_ROOT

Utilizzando l'esempio precedente, la directory e il modulo importato verranno chiamati classify_wrapper.

Passaggio 2: aggiorna il file build.gradle dell'app

Nel modulo dell'app che utilizzerà il modulo della libreria generato:

Nella sezione Android, aggiungi quanto segue:

aaptOptions {
   noCompress "tflite"
}

Nella sezione delle dipendenze, aggiungi quanto segue:

implementation project(":classify_wrapper")

Passaggio 3: utilizza il modello

// 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();
}

Accelerare l'inferenza del modello

Il codice generato offre agli sviluppatori un modo per accelerare il codice tramite l'utilizzo di delegati e del numero di thread. Questi possono essere impostati durante l'inizializzazione dell'oggetto modello, poiché richiede tre parametri:

  • Context: contesto dell'attività o del servizio Android
  • (Facoltativo) Device: delegato di accelerazione TFLite. Ad esempio: GPUDelegate
  • (Facoltativo) numThreads: numero di thread utilizzati per eseguire il modello. Il valore predefinito è 1.

Ad esempio, per utilizzare un delegato GPU e fino a tre thread, puoi inizializzare il modello nel seguente modo:

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

Risoluzione dei problemi

Se viene visualizzato l'errore "java.io.FileNotFoundException: This file can not be opened as a file descriptor; it is probably compressed", inserisci le seguenti righe nella sezione android del modulo dell'app che utilizzerà il modulo della libreria:

aaptOptions {
   noCompress "tflite"
}