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

À l'aide des métadonnées TensorFlow Lite, les développeurs peuvent générer un code wrapper pour permettre l'intégration sur Android. Pour la plupart des développeurs, l'interface graphique de la liaison de modèles de ML d'Android Studio est la plus facile à utiliser. Si vous avez besoin d'une personnalisation plus poussée ou si vous utilisez des outils de ligne de commande, le générateur TensorFlow Lite est également disponible.

Utiliser la liaison de modèle de ML d'Android Studio

Pour les modèles TensorFlow Lite améliorés à l'aide de métadonnées, les développeurs peuvent utiliser la liaison de modèles de ML d'Android Studio 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 du wrapper évite d'avoir à interagir directement avec ByteBuffer. À la place, 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. Effectuez un clic droit sur le module dans lequel vous souhaitez utiliser le modèle TFLite ou cliquez sur File, puis sur New > Other > TensorFlow Lite Model.

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

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

  3. Cliquez sur Finish.

  4. L'écran suivant s'affiche une fois l'importation terminée. Pour commencer à utiliser le modèle, sélectionnez Kotlin ou Java, puis copiez et collez le code dans la section Sample Code. Pour revenir à cet écran, double-cliquez sur le modèle TFLite dans le répertoire ml d'Android Studio.

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

La liaison de modèles de ML 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 dans le fichier build.gradle du module qu'il 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éterminez si le GPU exécuté sur l'appareil est compatible avec le délégué de GPU TensorFlow. Si ce n'est pas le cas, exécutez le modèle en utilisant plusieurs threads de processeur:

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

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 du wrapper Android TensorFlow Lite afin de créer un code de wrapper spécifique à la plate-forme. Le code du wrapper évite d'avoir à interagir directement avec ByteBuffer. À la place, 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 section <Codegen usage> sous les champs pertinents dans metadata_schema.fbs pour voir comment l'outil de génération de code analyse chaque champ.

Générer le code du wrapper

Vous devez installer les outils suivants dans votre terminal:

pip install tflite-support

Une fois l'opération terminée, vous pouvez utiliser le générateur de code selon 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 obtenu se trouve 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')

Utiliser le code généré

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

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

Ouvrez le projet Android Studio dans lequel vous souhaitez utiliser le modèle TensorFlow Lite, puis importez le module généré en procédant comme suit: SRC_ROOT

Dans l'exemple ci-dessus, le répertoire et le module importés sont 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é:

Dans la section Android, ajoutez les éléments suivants:

aaptOptions {
   noCompress "tflite"
}

Dans la section des dépendances, ajoutez les éléments suivants:

implementation project(":classify_wrapper")

Étape 3: Utiliser le 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érer 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 du nombre de threads. Ils peuvent être définis lors de l'initialisation de l'objet de modèle, car il nécessite trois paramètres:

  • Context: contexte de l'activité ou du service Android
  • (Facultatif) Device: délégué d'accélération TFLite. Par exemple : GPUDele
  • (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é de GPU et jusqu'à trois threads, vous pouvez initialiser le modèle comme suit:

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

Dépannage

Si vous obtenez une erreur "java.io.FileNotFoundException: This file can not be open as a file Descriptor; it is probablement compressé", insérez les lignes suivantes sous la section Android du module d'application qui utilisera le module de bibliothèque:

aaptOptions {
   noCompress "tflite"
}