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
Fai clic con il tasto destro del mouse sul modulo su cui vuoi utilizzare il modello TFLite o fai clic su
File
, quindiNew
>Other
>TensorFlow Lite Model
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.
Fai clic su
Finish
.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 directoryml
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"
}