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 code wrapper permettant d'activer l'intégration sur Android. Pour la plupart des développeurs, l'interface graphique de liaison de modèles de ML d'Android Studio est la le plus simple à utiliser. Si vous avez besoin d'une personnalisation plus poussée ou si vous utilisez la ligne de commande LiteRT Codegen est également disponible.

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

Pour les modèles LiteRT améliorés avec des métadonnées, les développeurs peuvent utiliser la liaison de modèles de ML d'Android Studio pour configurer automatiquement du projet et générer des classes wrapper en fonction du modèle. de métadonnées. 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 avec des objets typés tels que Bitmap et Rect.

Importer un modèle LiteRT dans Android Studio

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

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

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

  3. Cliquez sur Finish.

  4. L'écran suivant s'affiche une fois l'importation terminée. Pour commencer à l'aide du modèle, sélectionnez Kotlin ou Java, copiez le code et collez-le sous 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 via l'utilisation de délégués et le nombre de threads.

Étape 1 : Vérifiez que le fichier build.gradle du module contient les éléments suivants : la dépendance:

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

Étape 2 : Détecter si le GPU exécuté sur l'appareil est compatible avec les GPU TensorFlow délégué, si vous n'exécutez pas 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 le modèle LiteRT amélioré avec des métadonnées, les développeurs peuvent utiliser le générateur de code wrapper Android LiteRT pour créer un code de wrapper spécifique à la plate-forme. Le code du wrapper élimine la nécessité d'interagir directement avec ByteBuffer. À la place, les développeurs peuvent interagir avec TensorFlow Modèle Lite avec des objets typés tels que Bitmap et Rect.

L'utilité du générateur de code dépend de l'exhaustivité du Entrée de métadonnées du modèle LiteRT. Reportez-vous à la section <Codegen usage> sous les champs pertinents metadata_schema.fbs. pour voir comment l'outil Codegen 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, le générateur de code peut être utilisé à l'aide de 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 à l'aide de Google Colab ou d'une autre il peut être plus simple de compresser le résultat dans une archive zip et de télécharger à 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: Importez le code généré

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

Ouvrez le projet Android Studio dans lequel vous souhaitez utiliser LiteRT. et importer le module généré avec: And File -> Nouveau -> Importer un module -> sélectionner SRC_ROOT

Dans l'exemple ci-dessus, le répertoire et le module importés seront appelés classify_wrapper

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

Dans le module d'application qui utilisera 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 via l'utilisation de délégués et du nombre de les threads. Vous pouvez les définir lors de l'initialisation de l'objet de modèle. 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é 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 exception "java.io.FileNotFoundException: Ce fichier ne peut pas être ouvert en tant que descripteur de fichier elle est probablement compressée. insérez les lignes suivantes Dans la section Android du module d'application qui utilisera le module de bibliothèque:

aaptOptions {
   noCompress "tflite"
}