Sélectionner des opérateurs TensorFlow

Étant donné que la bibliothèque d'opérateurs intégrée LiteRT n'accepte qu'une un certain nombre d'opérateurs TensorFlow. Tous les modèles ne sont pas convertibles. Pour en savoir plus, consultez la section Compatibilité des opérateurs.

Pour autoriser la conversion, les utilisateurs peuvent activer l'utilisation de certains types de fichiers TensorFlow ops dans leur modèle LiteRT. Toutefois, l'exécution Les modèles LiteRT avec des opérations TensorFlow nécessitent Environnement d'exécution TensorFlow, qui augmente la taille binaire de l'interpréteur LiteRT. Pour Android, vous pouvez éviter cela en créant de manière sélective uniquement les composants TensorFlow opérations Pour en savoir plus, consultez la section Réduire le nombre la taille de l'image.

Ce document explique comment convertir et exécuter un modèle LiteRT contenant des opérations TensorFlow sur un la plate-forme de votre choix. Il aborde également les performances et la taille les métriques et les limites connues.

Convertir un modèle

L'exemple suivant montre comment générer un modèle LiteRT avec select TensorFlow Ops.

import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.target_spec.supported_ops = [
  tf.lite.OpsSet.TFLITE_BUILTINS, # enable LiteRT ops.
  tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.
]
tflite_model = converter.convert()
open("converted_model.tflite", "wb").write(tflite_model)

Exécuter une inférence

En cas d'utilisation d'un modèle LiteRT converti et compatible avec sélectionnez les opérations TensorFlow, le client doit également utiliser un environnement d'exécution LiteRT inclut la bibliothèque d'opérations TensorFlow nécessaire.

AAR Android

Pour réduire la taille du binaire, veuillez créer vos propres fichiers AAR personnalisés en suivant les instructions la section suivante. Si la taille binaire n'est pas nous vous recommandons d'utiliser l'AAR prédéfini avec les opérations TensorFlow hébergé sur MavenCentral.

Vous pouvez le spécifier dans vos dépendances build.gradle en l'ajoutant avec l'AAR LiteRT standard comme suit:

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    // This dependency adds the necessary TF op support.
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.0.0-nightly-SNAPSHOT'
}

Pour utiliser des instantanés nocturnes, assurez-vous d'avoir ajouté l'instantané Sonatype un dépôt de clés.

Une fois la dépendance ajoutée, le délégué nécessaire à la gestion du les opérations TensorFlow de graph doivent être automatiquement installées pour les graphes nécessitant de l'IA générative.

Remarque: La dépendance des opérations TensorFlow étant relativement importante, vous devrez probablement Vous souhaitez filtrer les ABI x86 inutiles dans votre fichier .gradle en configurant votre abiFilters.

android {
    defaultConfig {
        ndk {
            abiFilters 'armeabi-v7a', 'arm64-v8a'
        }
    }
}

Créer l'AAR Android

Pour réduire la taille binaire ou d'autres cas plus complexes, vous pouvez également créer le bibliothèque manuellement. En supposant qu'un build LiteRT fonctionne , créez l'AAR Android en sélectionnant les opérations TensorFlow en tant que ce qui suit:

sh tensorflow/lite/tools/build_aar.sh \
  --input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a

Le fichier AAR bazel-bin/tmp/tensorflow-lite.aar sera généré pour Opérations personnalisées et intégrées LiteRT et générer le fichier AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar pour les opérations TensorFlow. Si vous n'ont pas d'environnement de compilation opérationnel, vous pouvez également compiler les fichiers ci-dessus avec docker.

Vous pouvez alors importer les fichiers AAR directement dans votre projet ou Publiez les fichiers AAR personnalisés dans votre dépôt Maven local:

mvn install:install-file \
  -Dfile=bazel-bin/tmp/tensorflow-lite.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite -Dversion=0.1.100 -Dpackaging=aar
mvn install:install-file \
  -Dfile=bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite-select-tf-ops -Dversion=0.1.100 -Dpackaging=aar

Enfin, dans le fichier build.gradle de votre application, assurez-vous que mavenLocal() et remplacez la dépendance LiteRT standard par celle est compatible avec certaines opérations TensorFlow:

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
        mavenLocal()
    }
}

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.1.100'
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.1.100'
}

iOS

Utiliser CocoaPods

LiteRT fournit des CocoaPods de sélection de tâches TF prédéfinies la nuit pour arm64, dont vous pouvez dépendre en plus des TensorFlowLiteSwift ou TensorFlowLiteObjC CocoaPods.

Remarque: Si vous devez utiliser select TF Ops dans un simulateur x86_64, vous pouvez compiler sélectionnez vous-même le framework des opérations. Consultez la page Utiliser Bazel + Xcode. pour en savoir plus.

# In your Podfile target:
  pod 'TensorFlowLiteSwift'   # or 'TensorFlowLiteObjC'
  pod 'TensorFlowLiteSelectTfOps', '~> 0.0.1-nightly'

Après avoir exécuté pod install, vous devez fournir un indicateur d'association supplémentaire aux forcer le chargement du framework TF Ops sélectionné dans votre projet. Dans votre projet Xcode, accéder à Build Settings -> Other Linker Flags, puis ajoutez:

Pour les versions 2.9.0 ou ultérieures:

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.xcframework/ios-arm64/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

Pour les versions < 2.9.0:

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

Vous devriez ensuite pouvoir exécuter tous les modèles convertis avec SELECT_TF_OPS dans votre application iOS. Par exemple, vous pouvez modifier la classification d'images iOS application pour tester la fonctionnalité de sélection des opérations TensorFlow.

• Remplacez le fichier de modèle par celui converti avec SELECT_TF_OPS activé.
• Ajoutez la dépendance TensorFlowLiteSelectTfOps à Podfile comme indiqué.
• Ajoutez l'indicateur Linker supplémentaire comme indiqué ci-dessus.
• Exécutez l'exemple d'application et vérifiez si le modèle fonctionne correctement.

Utilisation de Bazel + Xcode

Avec certaines opérations TensorFlow pour iOS, LiteRT peut être créé à l'aide de Bazel. Tout d'abord, suivez les instructions de compilation iOS pour configurer votre l'espace de travail Bazel et le fichier .bazelrc correctement ;

Une fois que la compatibilité avec iOS est activée dans l'espace de travail, vous pouvez utiliser le pour créer le framework du module complémentaire select TF Ops, qui peut être ajouté en plus du TensorFlowLiteC.framework standard. Notez que l'opérateur select TF ops ne peut pas être créé pour l'architecture i386. Vous devez donc explicitement Fournissez la liste des architectures cibles, à l'exception de i386.

bazel build -c opt --config=ios --ios_multi_cpus=arm64,x86_64 \
  //tensorflow/lite/ios:TensorFlowLiteSelectTfOps_framework

Le framework sera généré dans bazel-bin/tensorflow/lite/ios/ . Vous pouvez ajouter ce nouveau framework à votre projet Xcode en suivant des étapes similaires décrites dans la section Projet Xcode du guide de création iOS.

Après avoir ajouté le framework à votre projet d'application, un indicateur d'association supplémentaire doit être spécifié dans votre projet d'application pour forcer le chargement des opérations TF Ops. d'infrastructure. Dans votre projet Xcode, accédez à Build Settings -> Other Linker Flags, puis ajoutez:

-force_load <path/to/your/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps>

C/C++

Si vous utilisez Bazel ou CMake pour compiler LiteRT vous pouvez activer la délégation Flex en associant un LiteRT Flex la bibliothèque partagée. Vous pouvez le compiler avec Bazel via la commande suivante.

bazel build -c opt --config=monolithic tensorflow/lite/delegates/flex:tensorflowlite_flex

Cette commande génère la bibliothèque partagée suivante dans bazel-bin/tensorflow/lite/delegates/flex

Notez que les TfLiteDelegate nécessaires sont installés automatiquement lorsque créer l'interpréteur au moment de l'exécution tant que la bibliothèque partagée est associée. Il n'est pas nécessaire pour installer explicitement l'instance déléguée, comme c'est généralement le cas requise avec d'autres types de délégués.

Remarque:Cette fonctionnalité est disponible depuis la version 2.7.

Python

LiteRT avec certaines opérations TensorFlow sera installé automatiquement avec Le package pip TensorFlow. Vous pouvez choisissez aussi d'installer uniquement le module d'interpréteur LiteRT pip package.

Métriques

Performances

Lorsque vous utilisez à la fois des opérations TensorFlow intégrées et des opérations TensorFlow sélectionnées, il n'y a pas de différence Les optimisations LiteRT et les opérations intégrées optimisées seront disponibles. utilisable avec le modèle converti.

Le tableau suivant décrit la durée moyenne d'exécution de l'inférence sur MobileNet sur un Pixel 2. Les durées indiquées correspondent à une moyenne de 100 courses. Ces cibles ont été créées pour Android à l'aide des indicateurs: --config=android_arm64 -c opt.

Taille binaire

Le tableau suivant décrit la taille binaire de LiteRT pour chaque build. Ces cibles ont été créées pour Android avec --config=android_arm -c opt.

(1) Ces bibliothèques ont été créées de façon sélective pour i3d-kinetics-400 modèle avec huit opérations TFLite intégrées et trois opérations Tensorflow. Pour en savoir plus, consultez les Section Réduire la taille binaire de LiteRT.

Limites connues

• Types non compatibles: certaines opérations TensorFlow peuvent ne pas être compatibles avec l'ensemble d'entrée/sortie généralement disponibles dans TensorFlow.

Mises à jour

• Version 2.6 <ph type="x-smartling-placeholder">
  </ph>
  • Compatible avec les opérateurs basés sur les attributs GraphDef et la ressource HashTable. l'initialisation.
• Version 2.5 <ph type="x-smartling-placeholder">
  </ph>
  • Vous pouvez appliquer une optimisation appelée post-entraînement quantification
• Version 2.4 <ph type="x-smartling-placeholder">
  </ph>
  • La compatibilité avec les délégués avec accélération matérielle s'est améliorée.