Générer des interfaces de modèle à l'aide de métadonnées

À l'aide de TensorFlow Lite Metadata , les développeurs peuvent générer du code wrapper pour permettre l'intégration sur Android. Pour la plupart des développeurs, l'interface graphique d' Android Studio ML Model Binding est la plus simple à utiliser. Si vous avez besoin de plus de personnalisation ou si vous utilisez des outils de ligne de commande, le codegen TensorFlow Lite est également disponible.

Utiliser la liaison de modèle Android Studio ML

Pour les modèles TensorFlow Lite améliorés avec des métadonnées , les développeurs peuvent utiliser Android Studio ML Model Binding pour configurer automatiquement les paramètres du projet et générer des classes wrapper basées sur les métadonnées du modèle. Le code wrapper supprime le besoin d'interagir directement avec ByteBuffer . Au lieu de cela, les développeurs peuvent interagir avec le modèle TensorFlow Lite avec des objets typés tels que Bitmap et Rect .

Importer un modèle TensorFlow Lite dans Android Studio

1. Faites un clic droit sur le module pour lequel vous souhaitez utiliser le modèle TFLite ou cliquez sur File , puis New > Other > TensorFlow Lite Model

2. Sélectionnez l'emplacement de votre fichier TFLite. Notez que l'outillage configurera la dépendance du module en votre nom avec la liaison du modèle ML et toutes les dépendances insérées automatiquement dans le fichier build.gradle de votre module Android.

   Facultatif : cochez la deuxième case pour importer le GPU TensorFlow si vous souhaitez utiliser l'accélération GPU.

3. Cliquez sur Finish .

4. L'écran suivant apparaîtra une fois l'importation réussie. Pour commencer à utiliser le modèle, sélectionnez Kotlin ou Java, copiez et collez le code sous la section Sample Code . Vous pouvez revenir à cet écran en double-cliquant sur le modèle TFLite sous le répertoire ml dans Android Studio.

Accélération de l'inférence de modèle

ML Model Binding permet aux développeurs d'accélérer leur code grâce à l'utilisation de délégués et au nombre de threads.

Étape 1. Vérifiez que le fichier build.gradle du module contient la dépendance suivante :

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

Étape 2. Détectez si le GPU exécuté sur l'appareil est compatible avec le délégué GPU TensorFlow, sinon exécutez le modèle à l'aide de plusieurs threads 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
      

Générer des interfaces de modèle avec le générateur de code TensorFlow Lite

Pour le modèle TensorFlow Lite amélioré avec des métadonnées , les développeurs peuvent utiliser le générateur de code wrapper Android TensorFlow Lite pour créer un code wrapper spécifique à la plate-forme. Le code wrapper supprime le besoin d'interagir directement avec ByteBuffer . Au lieu de cela, les développeurs peuvent interagir avec le modèle TensorFlow Lite avec des objets typés tels que Bitmap et Rect .

L'utilité du générateur de code dépend de l'exhaustivité de l'entrée de métadonnées du modèle TensorFlow Lite. Reportez-vous à la <Codegen usage> sous les champs pertinents dans metadata_schema.fbs , pour voir comment l'outil codegen analyse chaque champ.

Générer le code wrapper

Vous devrez installer les outils suivants dans votre terminal :

pip install tflite-support

Une fois terminé, le générateur de code peut être utilisé en utilisant la syntaxe suivante :

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

Le code résultant sera situé dans le répertoire de destination. Si vous utilisez Google Colab ou un autre environnement distant, il peut être plus simple de compresser le résultat dans une archive zip et de le télécharger dans votre projet 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')

Utilisation du code généré

Étape 1 : Importer le code généré

Décompressez le code généré si nécessaire dans une structure de répertoires. La racine du code généré est supposée être SRC_ROOT .

Ouvrez le projet Android Studio où vous souhaitez utiliser le modèle TensorFlow lite et importez le module généré par : Et Fichier -> Nouveau -> Importer le module -> sélectionnez SRC_ROOT

En utilisant l'exemple ci-dessus, le répertoire et le module importés seraient appelés classify_wrapper .

Étape 2 : Mettez à jour le fichier build.gradle de l'application

Dans le module d'application qui consommera le module de bibliothèque généré :

Sous la section Android, ajoutez ce qui suit :

aaptOptions {
   noCompress "tflite"
}

Sous la section des dépendances, ajoutez ce qui suit :

implementation project(":classify_wrapper")

Étape 3 : Utilisation du modèle

// 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();
}

Accélération de l'inférence de modèle

Le code généré permet aux développeurs d'accélérer leur code grâce à l'utilisation de délégués et au nombre de threads. Ceux-ci peuvent être définis lors de l'initialisation de l'objet modèle car il prend trois paramètres :

• Context : contexte de l'activité ou du service Android
• (Facultatif) Device : délégué d'accélération TFLite, par exemple GPUDelegate ou NNAPIDelegate
• (Facultatif) numThreads : nombre de threads utilisés pour exécuter le modèle - la valeur par défaut est un.

Par exemple, pour utiliser un délégué NNAPI et jusqu'à trois threads, vous pouvez initialiser le modèle comme ceci :

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

Dépannage

Si vous obtenez une exception 'java.io.FileNotFoundException : ce fichier ne peut pas être ouvert en tant que descripteur de fichier ; il s'agit probablement d'une erreur compressée, insérez les lignes suivantes sous la section Android du module d'application qui utilisera le module de bibliothèque :

aaptOptions {
   noCompress "tflite"
}