Genera interfacce modello utilizzando i metadati

Utilizzando TensorFlow Lite 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 da riga di comando, è disponibile anche TensorFlow Lite Codegen .

Usa l'associazione del modello 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 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 TensorFlow Lite con oggetti tipizzati come Bitmap e Rect .

Importa un modello TensorFlow Lite in Android Studio

1. Fare clic con il pulsante destro del mouse sul modulo in 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 la GPU TensorFlow se desideri utilizzare l'accelerazione GPU.

3. Fare clic su Finish .

4. La seguente schermata apparirà dopo che l'importazione è andata a buon fine. 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

ML Model Binding offre agli sviluppatori un modo per accelerare il proprio codice tramite l'uso di delegati e il numero di thread.

Passaggio 1. Verificare 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 modello con il generatore di codice TensorFlow Lite

Per il modello TensorFlow Lite potenziato con metadati , gli sviluppatori possono utilizzare il generatore di codice wrapper Android TensorFlow Lite per creare codice wrapper specifico della 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 dell'immissione 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 ogni 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 stai utilizzando 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 presume 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 da: E File -> Nuovo -> Modulo di importazione -> seleziona SRC_ROOT

Utilizzando l'esempio sopra, la directory e il modulo importati verrebbero chiamati classify_wrapper .

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

Nel modulo dell'app che consumerà 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: 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 consente agli sviluppatori di accelerare il proprio codice tramite l'uso di delegati e il numero di thread. Questi possono essere impostati durante l'inizializzazione dell'oggetto modello poiché richiede tre parametri:

• Context : contesto dall'attività o servizio Android
• (Facoltativo) Device : delegato di 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 ottieni un'eccezione 'java.io.FileNotFoundException: questo file non può essere aperto come descrittore di file; probabilmente è un errore compresso, inserisci le seguenti righe nella sezione Android del modulo dell'app che utilizzerà il modulo della libreria:

aaptOptions {
   noCompress "tflite"
}