Genera interfacce del modello utilizzando i metadati

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

Utilizzo dell'associazione di modelli ML di Android Studio

Per i modelli LiteRT migliorati con i metadati: gli sviluppatori possono usare l'associazione dei modelli ML di Android Studio per configurare automaticamente le impostazioni del progetto e generate classi wrapper in base al modello metadati. Il codice wrapper elimina la necessità di interagire direttamente con ByteBuffer. Gli sviluppatori possono invece interagire con il modello LiteRT con oggetti digitati come Bitmap e Rect.

Importa un modello LiteRT in Android Studio

  1. Fai clic con il tasto destro del mouse sul modulo che desideri utilizzare il modello TFLite oppure fai clic File, poi New > Other > LiteRT Model

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

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

  3. Fai clic su Finish.

  4. Una volta completata l'importazione, verrà visualizzata la seguente schermata. Per iniziare utilizzando il modello, seleziona Kotlin o Java, copia e incolla il codice Sezione Sample Code. Puoi tornare a questa schermata facendo doppio clic il modello TFLite nella directory ml di Android Studio.

Accelerazione dell'inferenza del modello

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

Passaggio 1. Verifica che il file del modulo build.gradle contenga quanto segue :

    dependencies {
        ...
        // TFLite GPU delegate 2.3.0 or above is required.
        implementation 'com.google.ai.edge.litert:litert-gpu:2.3.0'
    }

Passaggio 2: Rileva se la GPU in esecuzione sul dispositivo è compatibile con la GPU TensorFlow delegato, se non 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 del modello con il generatore di codice LiteRT

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

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

Genera codice wrapper

Dovrai installare i seguenti strumenti nel terminale:

pip install tflite-support

Al termine, potrai utilizzare il generatore di codice 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 tramite Google Colab o un altro telecomando potrebbe essere più semplice comprimere i risultati in un archivio zip e al 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 in una struttura di directory. La radice di si presume che il codice generato sia SRC_ROOT.

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

Utilizzando l’esempio precedente, la directory e il modulo importati saranno 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: 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 codice mediante l'uso di delegati e il numero di thread. Possono essere impostate durante l'inizializzazione dell'oggetto del modello, in quanto richiede tre parametri:

  • Context: contesto dell'attività o del servizio Android
  • (Facoltativo) Device: delegato per l'accelerazione TFLite. Ad esempio: GPUDelegate
  • (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 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 il messaggio "java.io.FileNotFoundException: Questo file non può essere aperto come file descrittore del file; probabilmente è compresso". inserisci le righe seguenti nella sezione Android del modulo dell'app che utilizzerà il modulo Libreria:

aaptOptions {
   noCompress "tflite"
}