L'utilisation de processeurs spécialisés tels que les GPU, les NPU ou les DSP pour l'accélération matérielle peut considérablement améliorer les performances d'inférence (inférence jusqu'à 10 fois plus rapide dans certains cas) et l'expérience utilisateur de votre application Android compatible ML. Cependant, étant donné la variété de matériels et de pilotes dont disposent vos utilisateurs, choisir la configuration d'accélération matérielle optimale pour l'appareil de chaque utilisateur peut s'avérer difficile. De plus, l'activation d'une mauvaise configuration sur un appareil peut créer une mauvaise expérience utilisateur en raison d'une latence élevée ou, dans de rares cas, d'erreurs d'exécution ou de problèmes de précision causés par des incompatibilités matérielles.
Acceleration Service for Android est une API qui vous aide à choisir la configuration d'accélération matérielle optimale pour un appareil utilisateur donné et votre modèle .tflite , tout en minimisant le risque d'erreur d'exécution ou de problèmes de précision.
Le service d'accélération évalue différentes configurations d'accélération sur les appareils des utilisateurs en exécutant des tests d'inférence internes avec votre modèle TensorFlow Lite. Ces tests s'exécutent généralement en quelques secondes, selon votre modèle. Vous pouvez exécuter les benchmarks une fois sur chaque machine utilisateur avant le moment de l'inférence, mettre en cache le résultat et l'utiliser pendant l'inférence. Ces repères sont exécutés hors processus; ce qui minimise le risque de plantage de votre application.
Fournissez votre modèle, des échantillons de données et les résultats attendus (entrées et sorties « dorées ») et le service d'accélération exécutera un benchmark d'inférence TFLite interne pour vous fournir des recommandations matérielles.
Acceleration Service fait partie de la pile ML personnalisée d'Android et fonctionne avec TensorFlow Lite dans les services Google Play .
Ajouter les dépendances à votre projet
Ajoutez les dépendances suivantes au fichier build.gradle de votre application :
implementation "com.google.android.gms:play-services-tflite-
acceleration-service:16.0.0-beta01"
L'API Acceleration Service fonctionne avec TensorFlow Lite dans Google Play Services . Si vous n'utilisez pas encore l'environnement d'exécution TensorFlow Lite fourni via Play Services, vous devrez mettre à jour vos dépendances .
Comment utiliser l'API du service d'accélération
Pour utiliser Acceleration Service, commencez par créer la configuration d'accélération que vous souhaitez évaluer pour votre modèle (par exemple, GPU avec OpenGL). Créez ensuite une configuration de validation avec votre modèle, des exemples de données et la sortie de modèle attendue. Enfin, appelez validateConfig() en passant à la fois votre configuration d'accélération et votre configuration de validation.
Créer des configurations d'accélération
Les configurations d'accélération sont des représentations des configurations matérielles qui sont traduites en délégués pendant le temps d'exécution. Le service d'accélération utilisera ensuite ces configurations en interne pour effectuer des inférences de test.
Pour le moment, le service d'accélération vous permet d'évaluer les configurations GPU (converties en délégué GPU pendant le temps d'exécution) avec GpuAccelerationConfig et l'inférence CPU (avec CpuAccelerationConfig ). Nous travaillons à aider davantage de délégués à accéder à d'autres matériels à l'avenir.
Configuration de l'accélération GPU
Créez une configuration d'accélération GPU comme suit :
AccelerationConfig accelerationConfig = new GpuAccelerationConfig.Builder()
.setEnableQuantizedInference(false)
.build();
Vous devez spécifier si votre modèle utilise ou non la quantification avec setEnableQuantizedInference() .
Configuration de l'accélération du processeur
Créez l'accélération CPU comme suit :
AccelerationConfig accelerationConfig = new CpuAccelerationConfig.Builder()
.setNumThreads(2)
.build();
Utilisez la méthode setNumThreads() pour définir le nombre de threads que vous souhaitez utiliser pour évaluer l'inférence CPU.
Créer des configurations de validation
Les configurations de validation vous permettent de définir comment vous souhaitez que le service d'accélération évalue les inférences. Vous les utiliserez pour passer :
- échantillons d'entrée,
- les sorties attendues,
- logique de validation de la précision.
Assurez-vous de fournir des échantillons d'entrée pour lesquels vous attendez une bonne performance de votre modèle (également appelés échantillons « or »).
Créez un ValidationConfig avec CustomValidationConfig.Builder comme suit :
ValidationConfig validationConfig = new CustomValidationConfig.Builder()
.setBatchSize(5)
.setGoldenInputs(inputs)
.setGoldenOutputs(outputBuffer)
.setAccuracyValidator(new MyCustomAccuracyValidator())
.build();
Spécifiez le nombre d'échantillons de référence avec setBatchSize() . Passez les entrées de vos échantillons dorés à l'aide de setGoldenInputs() . Fournissez la sortie attendue pour l'entrée transmise avec setGoldenOutputs() .
Vous pouvez définir un temps d'inférence maximum avec setInferenceTimeoutMillis() (5000 ms par défaut). Si l'inférence prend plus de temps que le temps que vous avez défini, la configuration sera rejetée.
En option, vous pouvez également créer un AccuracyValidator personnalisé comme suit :
class MyCustomAccuracyValidator implements AccuracyValidator {
boolean validate(
BenchmarkResult benchmarkResult,
ByteBuffer[] goldenOutput) {
for (int i = 0; i < benchmarkResult.actualOutput().size(); i++) {
if (!goldenOutputs[i]
.equals(benchmarkResult.actualOutput().get(i).getValue())) {
return false;
}
}
return true;
}
}
Assurez-vous de définir une logique de validation qui fonctionne pour votre cas d'utilisation.
Notez que si les données de validation sont déjà intégrées dans votre modèle, vous pouvez utiliser EmbeddedValidationConfig .
Générer des sorties de validation
Les sorties dorées sont facultatives et tant que vous fournissez des entrées dorées, le service d'accélération peut générer en interne les sorties dorées. Vous pouvez également définir la configuration d'accélération utilisée pour générer ces sorties dorées en appelant setGoldenConfig() :
ValidationConfig validationConfig = new CustomValidationConfig.Builder()
.setBatchSize(5)
.setGoldenInputs(inputs)
.setGoldenConfig(customCpuAccelerationConfig)
[...]
.build();
Valider la configuration de l'accélération
Une fois que vous avez créé une configuration d'accélération et une configuration de validation, vous pouvez les évaluer pour votre modèle.
Assurez-vous que l'environnement d'exécution TensorFlow Lite with Play Services est correctement initialisé et que le délégué GPU est disponible pour l'appareil en exécutant :
TfLiteGpu.isGpuDelegateAvailable(context)
.onSuccessTask(gpuAvailable -> TfLite.initialize(context,
TfLiteInitializationOptions.builder()
.setEnableGpuDelegateSupport(gpuAvailable)
.build()
)
);
Instanciez AccelerationService en appelant AccelerationService.create() .
Vous pouvez ensuite valider votre configuration d'accélération pour votre modèle en appelant validateConfig() :
InterpreterApi interpreter;
InterpreterOptions interpreterOptions = InterpreterApi.Options();
AccelerationService.create(context)
.validateConfig(model, accelerationConfig, validationConfig)
.addOnSuccessListener(validatedConfig -> {
if (validatedConfig.isValid() && validatedConfig.benchmarkResult().hasPassedAccuracyTest()) {
interpreterOptions.setAccelerationConfig(validatedConfig);
interpreter = InterpreterApi.create(model, interpreterOptions);
});
Vous pouvez également valider plusieurs configurations en appelant validateConfigs() et en transmettant un objet Iterable<AccelerationConfig> en tant que paramètre.
validateConfig() renverra une Task< ValidatedAccelerationConfigResult > de l' API de tâche des services Google Play qui active les tâches asynchrones.
Pour obtenir le résultat de l'appel de validation, ajoutez un rappel addOnSuccessListener() .
Utilisez une configuration validée dans votre interpréteur
Après avoir vérifié si le ValidatedAccelerationConfigResult renvoyé dans le rappel est valide, vous pouvez définir la configuration validée en tant que configuration d'accélération pour votre interpréteur en appelant interpreterOptions.setAccelerationConfig() .
Mise en cache de la configuration
Il est peu probable que la configuration d'accélération optimale pour votre modèle change sur l'appareil. Ainsi, une fois que vous recevez une configuration d'accélération satisfaisante, vous devez la stocker sur l'appareil et laisser votre application la récupérer et l'utiliser pour créer vos InterpreterOptions lors des sessions suivantes au lieu d'exécuter une autre validation. Les méthodes serialize() et deserialize() dans ValidatedAccelerationConfigResult facilitent le processus de stockage et de récupération.
Exemple de demande
Pour examiner une intégration in situ du service d'accélération, consultez l' exemple d'application .
Limites
Le service d'accélération présente actuellement les limitations suivantes :
- Seules les configurations d'accélération CPU et GPU sont prises en charge pour le moment,
- Il ne prend en charge que TensorFlow Lite dans les services Google Play et vous ne pouvez pas l'utiliser si vous utilisez la version groupée de TensorFlow Lite,
- Il ne prend pas en charge la bibliothèque de tâches TensorFlow Lite, car vous ne pouvez pas initialiser directement
BaseOptionsavec l'objetValidatedAccelerationConfigResult. - Acceleration Service SDK prend uniquement en charge le niveau d'API 22 et supérieur.
Mises en garde
Veuillez lire attentivement les mises en garde suivantes, en particulier si vous envisagez d'utiliser ce SDK en production :
Avant de quitter la version bêta et de publier la version stable de l'API Acceleration Service, nous publierons un nouveau SDK qui peut présenter quelques différences par rapport à la version bêta actuelle. Afin de continuer à utiliser le service d'accélération, vous devrez migrer vers ce nouveau SDK et pousser une mise à jour de votre application en temps opportun. Ne pas le faire peut entraîner des pannes car le SDK bêta peut ne plus être compatible avec les services Google Play après un certain temps.
Il n'y a aucune garantie qu'une fonctionnalité spécifique au sein de l'API Acceleration Service ou de l'API dans son ensemble deviendra un jour généralement disponible. Il peut rester en version bêta indéfiniment, être arrêté ou être combiné avec d'autres fonctionnalités dans des packages conçus pour des publics de développeurs spécifiques. Certaines fonctionnalités de l'API Acceleration Service ou de l'intégralité de l'API elle-même peuvent éventuellement devenir généralement disponibles, mais il n'y a pas de calendrier fixe pour cela.
Termes et confidentialité
Conditions d'utilisation
L'utilisation des API du service d'accélération est soumise aux conditions d'utilisation des API Google .
De plus, les API du service d'accélération sont actuellement en version bêta et, en tant que telles, en les utilisant, vous reconnaissez les problèmes potentiels décrits dans la section Mises en garde ci-dessus et reconnaissez que le service d'accélération peut ne pas toujours fonctionner comme spécifié.
Confidentialité
Lorsque vous utilisez les API du service d'accélération, le traitement des données d'entrée (par exemple, images, vidéo, texte) s'effectue intégralement sur l'appareil, et le service d'accélération n'envoie pas ces données aux serveurs Google . Par conséquent, vous pouvez utiliser nos API pour traiter les données d'entrée qui ne doivent pas quitter l'appareil.
Les API du service d'accélération peuvent contacter les serveurs de Google de temps à autre afin de recevoir des éléments tels que des correctifs de bogues, des modèles mis à jour et des informations sur la compatibilité des accélérateurs matériels. Les API du service d'accélération envoient également à Google des métriques sur les performances et l'utilisation des API dans votre application. Google utilise ces données de métrique pour mesurer les performances, déboguer, maintenir et améliorer les API, et détecter les abus ou les abus, comme décrit plus en détail dans notre Politique de confidentialité .
Vous êtes tenu d'informer les utilisateurs de votre application du traitement par Google des données des statistiques du service d'accélération, conformément à la législation en vigueur.
Les données que nous collectons incluent les éléments suivants :
- Informations sur l'appareil (telles que le fabricant, le modèle, la version et la version du système d'exploitation) et les accélérateurs matériels ML disponibles (GPU et DSP). Utilisé pour les diagnostics et l'analyse de l'utilisation.
- Informations sur l'application (nom du package / identifiant du package, version de l'application). Utilisé pour les diagnostics et l'analyse de l'utilisation.
- Configuration de l'API (telle que le format et la résolution de l'image). Utilisé pour les diagnostics et l'analyse de l'utilisation.
- Type d'événement (tel que l'initialisation, le téléchargement du modèle, la mise à jour, l'exécution, la détection). Utilisé pour les diagnostics et l'analyse de l'utilisation.
- Codes d'erreur. Utilisé pour le diagnostic.
- Indicateurs de performance. Utilisé pour le diagnostic.
- Identifiants par installation qui n'identifient pas de manière unique un utilisateur ou un appareil physique. Utilisé pour le fonctionnement de la configuration à distance et l'analyse de l'utilisation.
- Adresses IP de l'expéditeur de la requête réseau. Utilisé pour les diagnostics de configuration à distance. Les adresses IP collectées sont conservées temporairement.
Soutien et commentaires
Vous pouvez fournir des commentaires et obtenir de l'aide via l'outil de suivi des problèmes TensorFlow. Veuillez signaler les problèmes et les demandes d'assistance à l'aide du modèle de problème pour TensorFlow Lite dans les services Google Play.