Genera interfacce modello utilizzando i metadati

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

Utilizza l'associazione di modelli Android Studio ML

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

Importa un modello TensorFlow Lite in Android Studio

1. Fare clic con il tasto destro sul modulo per cui si desidera utilizzare il modello TFLite o fare clic su File , quindi New > Other > TensorFlow Lite Model

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

   Facoltativo: seleziona la seconda casella di controllo per importare TensorFlow GPU se desideri utilizzare l'accelerazione GPU.

3. Fare clic su Finish .

4. La seguente schermata verrà visualizzata una volta completata l'importazione. 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 in Android Studio.

Accelerazione dell'inferenza del modello

L'associazione di modelli ML offre agli sviluppatori un modo per accelerare il codice tramite l'uso di delegati e il numero di thread.

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

    dependencies {
        ...
        // TFLite GPU delegate 2.3.0 or above is required.
        implementation 'org.tensorflow:tensorflow-lite-gpu:2.3.0'
    }

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:

    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
      

    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
      

Genera interfacce di modelli con il generatore di codice TensorFlow Lite

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

L'utilità del generatore di codice dipende dalla completezza della voce dei metadati del modello TensorFlow Lite. Fare riferimento alla sezione <Codegen usage> sotto i campi pertinenti in metadata_schema.fbs per vedere come lo strumento codegen analizza ciascun campo.

Genera codice wrapper

Dovrai installare i seguenti strumenti nel tuo terminale:

pip install tflite-support

Una volta completato, il generatore di codice può essere utilizzato utilizzando 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, forse è più semplice comprimere il risultato in un archivio zip e scaricarlo nel tuo 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')

Utilizzando il codice generato

Passaggio 1: importa il codice generato

Decomprimere il codice generato, se necessario, in una struttura di directory. Si presuppone che la radice del codice generato sia SRC_ROOT .

Apri il progetto Android Studio in cui desideri utilizzare il modello TensorFlow lite e importa il modulo generato selezionando: E File -> Nuovo -> Importa modulo -> seleziona SRC_ROOT

Utilizzando l'esempio precedente, la directory e il modulo importati verrebbero 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 dipendenze, aggiungi quanto segue:

implementation project(":classify_wrapper")

Passaggio 3: utilizzo del 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();
}

Accelerazione dell'inferenza del modello

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

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

Ad esempio, per utilizzare un delegato NNAPI e fino a tre thread, puoi inizializzare il modello in questo modo:

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

Risoluzione dei problemi

Se ricevi una 'java.io.FileNotFoundException: questo file non può essere aperto come descrittore di file; probabilmente è un errore di compressione, inserisci le seguenti righe nella sezione Android del modulo dell'app che utilizzerà il modulo della libreria:

aaptOptions {
   noCompress "tflite"
}