Délégué TensorFlow Lite Hexagon

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Ce document explique comment utiliser TensorFlow Lite Hexagon Delegate dans votre application à l'aide de l'API Java et/ou C. Le délégué exploite la bibliothèque Qualcomm Hexagon pour exécuter des noyaux quantifiés sur le DSP. Notez que le délégué est destiné à compléter la fonctionnalité NNAPI, en particulier pour les périphériques où l'accélération NNAPI DSP n'est pas disponible (par exemple, sur des périphériques plus anciens ou des périphériques qui n'ont pas encore de pilote DSP NNAPI).

Périphériques compatibles:

Actuellement, les architectures Hexagon suivantes sont prises en charge, y compris, mais sans s'y limiter :

  • Hexagone 680
    • Exemples de SoC : Snapdragon 821, 820, 660
  • Hexagone 682
    • Exemples de SoC : Snapdragon 835
  • Hexagone 685
    • Exemples de SoC : Snapdragon 845, Snapdragon 710, QCS410, QCS610, QCS605, QCS603
  • Hexagone 690
    • Exemples de SoC : Snapdragon 855, RB5

Modèles pris en charge :

Le délégué Hexagon prend en charge tous les modèles conformes à notre spécification de quantification symétrique 8 bits , y compris ceux générés à l'aide de la quantification entière post-formation . Les modèles UInt8 formés avec le parcours de formation compatible avec la quantification hérité sont également pris en charge, par exemple, ces versions quantifiées sur notre page Modèles hébergés.

API Java déléguée Hexagon

public class HexagonDelegate implements Delegate, Closeable {

  /*
   * Creates a new HexagonDelegate object given the current 'context'.
   * Throws UnsupportedOperationException if Hexagon DSP delegation is not
   * available on this device.
   */
  public HexagonDelegate(Context context) throws UnsupportedOperationException


  /**
   * Frees TFLite resources in C runtime.
   *
   * User is expected to call this method explicitly.
   */
  @Override
  public void close();
}

Exemple d'utilisation

Étape 1. Modifiez app/build.gradle pour utiliser l'AAR délégué nocturne Hexagon

dependencies {
  ...
  implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
  implementation 'org.tensorflow:tensorflow-lite-hexagon:0.0.0-nightly-SNAPSHOT'
}

Étape 2. Ajoutez des bibliothèques Hexagon à votre application Android

  • Téléchargez et exécutez hexagon_nn_skel.run. Il devrait fournir 3 bibliothèques partagées différentes "libhexagon_nn_skel.so", "libhexagon_nn_skel_v65.so", "libhexagon_nn_skel_v66.so"

Étape 3. Créer un délégué et initialiser un interpréteur TensorFlow Lite

import org.tensorflow.lite.HexagonDelegate;

// Create the Delegate instance.
try {
  hexagonDelegate = new HexagonDelegate(activity);
  tfliteOptions.addDelegate(hexagonDelegate);
} catch (UnsupportedOperationException e) {
  // Hexagon delegate is not supported on this device.
}

tfliteInterpreter = new Interpreter(tfliteModel, tfliteOptions);

// Dispose after finished with inference.
tfliteInterpreter.close();
if (hexagonDelegate != null) {
  hexagonDelegate.close();
}

API Hexagon délégué C

struct TfLiteHexagonDelegateOptions {
  // This corresponds to the debug level in the Hexagon SDK. 0 (default)
  // means no debug.
  int debug_level;
  // This corresponds to powersave_level in the Hexagon SDK.
  // where 0 (default) means high performance which means more power
  // consumption.
  int powersave_level;
  // If set to true, performance information about the graph will be dumped
  // to Standard output, this includes cpu cycles.
  // WARNING: Experimental and subject to change anytime.
  bool print_graph_profile;
  // If set to true, graph structure will be dumped to Standard output.
  // This is usually beneficial to see what actual nodes executed on
  // the DSP. Combining with 'debug_level' more information will be printed.
  // WARNING: Experimental and subject to change anytime.
  bool print_graph_debug;
};

// Return a delegate that uses Hexagon SDK for ops execution.
// Must outlive the interpreter.
TfLiteDelegate*
TfLiteHexagonDelegateCreate(const TfLiteHexagonDelegateOptions* options);

// Do any needed cleanup and delete 'delegate'.
void TfLiteHexagonDelegateDelete(TfLiteDelegate* delegate);

// Initializes the DSP connection.
// This should be called before doing any usage of the delegate.
// "lib_directory_path": Path to the directory which holds the
// shared libraries for the Hexagon NN libraries on the device.
void TfLiteHexagonInitWithPath(const char* lib_directory_path);

// Same as above method but doesn't accept the path params.
// Assumes the environment setup is already done. Only initialize Hexagon.
Void TfLiteHexagonInit();

// Clean up and switch off the DSP connection.
// This should be called after all processing is done and delegate is deleted.
Void TfLiteHexagonTearDown();

Exemple d'utilisation

Étape 1. Modifiez app/build.gradle pour utiliser l'AAR délégué nocturne Hexagon

dependencies {
  ...
  implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
  implementation 'org.tensorflow:tensorflow-lite-hexagon:0.0.0-nightly-SNAPSHOT'
}

Étape 2. Ajoutez des bibliothèques Hexagon à votre application Android

  • Téléchargez et exécutez hexagon_nn_skel.run. Il devrait fournir 3 bibliothèques partagées différentes "libhexagon_nn_skel.so", "libhexagon_nn_skel_v65.so", "libhexagon_nn_skel_v66.so"

Étape 3. Inclure l'en-tête C

  • Le fichier d'en-tête "hexagon_delegate.h" peut être téléchargé depuis GitHub ou extrait de l'AAR délégué Hexagon.

Étape 4. Créer un délégué et initialiser un interpréteur TensorFlow Lite

  • Dans votre code, assurez-vous que la bibliothèque Hexagon native est chargée. Cela peut être fait en appelant System.loadLibrary("tensorflowlite_hexagon_jni");
    dans votre point d'entrée Activity ou Java.

  • Créer un délégué, exemple :

#include "tensorflow/lite/delegates/hexagon/hexagon_delegate.h"

// Assuming shared libraries are under "/data/local/tmp/"
// If files are packaged with native lib in android App then it
// will typically be equivalent to the path provided by
// "getContext().getApplicationInfo().nativeLibraryDir"
const char[] library_directory_path = "/data/local/tmp/";
TfLiteHexagonInitWithPath(library_directory_path);  // Needed once at startup.
::tflite::TfLiteHexagonDelegateOptions params = {0};
// 'delegate_ptr' Need to outlive the interpreter. For example,
// If use case will need to resize input or anything that can trigger
// re-applying delegates then 'delegate_ptr' need to outlive the interpreter.
auto* delegate_ptr = ::tflite::TfLiteHexagonDelegateCreate(&params);
Interpreter::TfLiteDelegatePtr delegate(delegate_ptr,
  [](TfLiteDelegate* delegate) {
    ::tflite::TfLiteHexagonDelegateDelete(delegate);
  });
interpreter->ModifyGraphWithDelegate(delegate.get());
// After usage of delegate.
TfLiteHexagonTearDown();  // Needed once at end of app/DSP usage.

Ajouter la bibliothèque partagée à votre application

  • Créez le dossier « app/src/main/jniLibs » et créez un répertoire pour chaque architecture cible. Par exemple,
    • ARM 64 bits : app/src/main/jniLibs/arm64-v8a
    • ARM 32 bits : app/src/main/jniLibs/armeabi-v7a
  • Mettez votre .so dans le répertoire qui correspond à l'architecture.

Retour d'information

Pour les problèmes, veuillez créer un problème GitHub avec tous les détails de reproduction nécessaires, y compris le modèle de téléphone et la carte utilisés ( adb shell getprop ro.product.device et adb shell getprop ro.board.platform ).

FAQ

  • Quelles opérations sont prises en charge par le délégué ?
  • Comment puis-je savoir que le modèle utilise le DSP lorsque j'active le délégué ?
    • Deux messages de journal seront imprimés lorsque vous activez le délégué - un pour indiquer si le délégué a été créé et un autre pour indiquer combien de nœuds s'exécutent à l'aide du délégué.
      Created TensorFlow Lite delegate for Hexagon.
      Hexagon delegate: X nodes delegated out of Y nodes.
  • Ai-je besoin que toutes les opérations du modèle soient prises en charge pour exécuter le délégué ?
    • Non, le modèle sera divisé en sous-graphiques en fonction des opérations prises en charge. Toutes les opérations non prises en charge s'exécuteront sur le processeur.
  • Comment puis-je créer l'AAR délégué Hexagon à partir de la source ?
    • Utilisez bazel build -c opt --config=android_arm64 tensorflow/lite/delegates/hexagon/java:tensorflow-lite-hexagon .
  • Pourquoi le délégué Hexagon ne parvient-il pas à s'initialiser alors que mon appareil Android dispose d'un SoC pris en charge ?
    • Vérifiez si votre appareil dispose bien d'un SoC pris en charge. Exécutez adb shell cat /proc/cpuinfo | grep Hardware et voyez s'il renvoie quelque chose comme "Hardware : Qualcomm Technologies, Inc MSMXXXX".
    • Certains fabricants de téléphones utilisent différents SoC pour le même modèle de téléphone. Par conséquent, le délégué Hexagon ne peut fonctionner que sur certains appareils du même modèle de téléphone, mais pas sur tous.
    • Certains fabricants de téléphones restreignent intentionnellement l'utilisation de Hexagon DSP à partir d'applications Android non système, ce qui empêche le délégué Hexagon de fonctionner.
  • Mon téléphone a verrouillé l'accès DSP. J'ai rooté le téléphone et je n'arrive toujours pas à lancer le délégué, que faire ?
    • Assurez-vous de désactiver l'application SELinux en exécutant adb shell setenforce 0