Genera interfacce del modello utilizzando i metadati

Con i metadati TensorFlow Lite, gli sviluppatori possono generare codice di wrapping per abilitare l'integrazione su Android. Per la maggior parte degli sviluppatori, l'interfaccia grafica dell'associazione di modelli ML di Android Studio è la più facile da usare. Se hai bisogno di una maggiore personalizzazione o se utilizzi strumenti a riga di comando, è disponibile anche TensorFlow Lite Codegen.

Usa associazione modelli ML di Android Studio

Per i modelli TensorFlow Lite migliorati con i metadati, gli sviluppatori possono utilizzare l'associazione dei modelli ML di Android Studio per configurare automaticamente le impostazioni per il progetto e generare classi di wrapper in base ai metadati del modello. Il codice wrapper elimina la necessità di interagire direttamente con ByteBuffer. Possono però interagire con il modello TensorFlow Lite con oggetti digitati come Bitmap e Rect.

Importa un modello TensorFlow Lite in Android Studio

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

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

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

  3. Fai clic su Finish.

  4. Una volta completata l'importazione, viene visualizzata la schermata seguente. 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.

Accelerazione dell'inferenza del modello

L'associazione di modelli ML consente agli sviluppatori di accelerare il proprio codice tramite l'uso dei delegati e il numero di thread.

Passaggio 1. Controlla il file build.gradle del modulo che contiene 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 della 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

Genera interfacce di modelli con il generatore di codice TensorFlow Lite

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

L'utilità del generatore di codice dipende dalla completezza della voce dei metadati del modello TensorFlow Lite. Consulta la sezione <Codegen usage> nei campi pertinenti di metadata_schema.fbs per vedere in che modo lo strumento codegen analizza ogni campo.

Genera codice wrapper

Dovrai installare i seguenti strumenti nel terminale:

pip install tflite-support

Al termine, 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 verrà posizionato nella directory di destinazione. Se usi Google Colab o un altro ambiente remoto, potrebbe essere più semplice comprimere i risultati in un archivio ZIP e scaricarli 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')

Utilizzo del codice generato

Passaggio 1: importa il codice generato

Se necessario, decomprimi il codice generato all'interno di una struttura di directory. La radice del codice generato si presume sia SRC_ROOT.

Apri il progetto Android Studio in cui vuoi utilizzare il modello TensorFlow Lite e importa il modulo generato procedendo nel seguente modo: File -> Nuovo -> Importa modulo -> seleziona SRC_ROOT

Nell'esempio riportato sopra, la directory e il modulo importati si chiameranno 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 dei delegati e il numero di thread. Puoi impostare questi parametri durante l'inizializzazione dell'oggetto del modello in tre parametri:

  • Context: contesto dall'attività o dal servizio Android
  • (Facoltativo) Device: delegato per l'accelerazione TFLite. Ad esempio: GPUDelega
  • (Facoltativo) numThreads: numero di thread utilizzati per eseguire il modello; il valore predefinito è uno.

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

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

Risoluzione dei problemi

Se visualizzi l'errore "java.io.FileNotFoundException: This file can not be open come file descriptor; probabilmente is compressi" (probabilmente è compresso), inserisci le seguenti righe nella sezione Android del modulo dell'app che utilizzerà il modulo Library:

aaptOptions {
   noCompress "tflite"
}