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

À l'aide des métadonnées LiteRT, 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 de la liaison de modèle ML Android Studio est la plus simple à utiliser. Si vous avez besoin de plus de personnalisation ou si vous utilisez des outils de ligne de commande, le LiteRT Codegen est également disponible.

Utiliser la liaison de modèle ML Android Studio

Pour les modèles LiteRT améliorés avec des métadonnées, les développeurs peuvent utiliser la liaison de modèle ML Android Studio pour configurer automatiquement les paramètres du projet et générer des classes wrapper en fonction des métadonnées du modèle. Le code du wrapper élimine la nécessité d'interagir directement avec ByteBuffer. Au lieu de cela, les développeurs peuvent interagir avec le modèle LiteRT à l'aide d'objets typés tels que Bitmap et Rect.

Importer un modèle LiteRT dans Android Studio

  1. Effectuez un clic droit sur le module que vous souhaitez utiliser avec le modèle TFLite ou cliquez sur File, puis sur New > Other > LiteRT Model.

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

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

  3. Cliquez sur Finish.

  4. L'écran suivant s'affiche une fois l'importation réussie. Pour commencer à utiliser le modèle, sélectionnez Kotlin ou Java, puis 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érer l'inférence de modèle

La liaison de modèles de ML permet aux développeurs d'accélérer leur code en utilisant des délégués et le nombre de threads.

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

    dependencies {
        ...
        // For the LiteRT GPU delegate, we need
        // 'com.google.ai.edge.litert:litert-gpu' version 1.*.
        implementation 'com.google.ai.edge.litert:litert-gpu:1.4.1'
    }

Étape 2 : Détectez si le GPU exécuté sur l'appareil est compatible avec le délégué TensorFlow GPU. Si ce n'est pas le cas, exécutez le modèle à l'aide de 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 LiteRT

Pour les modèles LiteRT améliorés avec des métadonnées, les développeurs peuvent utiliser le générateur de code wrapper LiteRT pour Android afin de créer du code wrapper spécifique à la plate-forme. Le code du wrapper élimine la nécessité d'interagir directement avec ByteBuffer. Au lieu de cela, les développeurs peuvent interagir avec le modèle TensorFlow Lite à l'aide d'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 LiteRT. Consultez la section <Codegen usage> sous les champs concernés dans metadata_schema.fbs pour savoir comment l'outil de génération de code analyse chaque champ.

Générer le code du 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é avec 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 trouvera dans le répertoire de destination. Si vous utilisez Google Colab ou un autre environnement à distance, il peut être plus facile 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épertoire. 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 LiteRT et importez le module généré en sélectionnant Fichier > Nouveau > Importer un module > SRC_ROOT.

En reprenant l'exemple ci-dessus, le répertoire et le module importé 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 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. Vous pouvez les définir lors de l'initialisation de l'objet de modèle, car il accepte 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
  • (Facultatif) numThreads : nombre de threads utilisés pour exécuter le modèle (la valeur par défaut est 1).

Par exemple, pour utiliser un délégué 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 recevez l'erreur "java.io.FileNotFoundException: This file can not be opened as a file descriptor; it is probably compressed" (java.io.FileNotFoundException : ce fichier ne peut pas être ouvert en tant que descripteur de fichier, il est 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"
}