L'utilisation de processeurs spécialisés tels que des GPU, NPU ou DSP pour l'accélération matérielle peut améliorer considérablement 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é du matériel et des pilotes dont vos utilisateurs peuvent disposer, choisir la configuration d'accélération matérielle optimale pour le périphérique de chaque utilisateur peut s'avérer difficile. De plus, activer 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 pour 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.
Acceleration Service é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 se terminent généralement en quelques secondes, selon votre modèle. Vous pouvez exécuter les tests de performance une fois sur chaque appareil utilisateur avant le moment de l'inférence, mettre en cache le résultat et l'utiliser pendant l'inférence. Ces benchmarks sont exécutés hors processus ; ce qui minimise le risque de plantage de votre application.
Fournissez votre modèle, vos échantillons de données et les résultats attendus (entrées et sorties « en or ») et Acceleration Service exécutera un test 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 .
Ajoutez 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 les services Google Play . Si vous n'utilisez pas encore le runtime TensorFlow Lite fourni via les services Play, 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, quelques exemples de données et la sortie attendue du modèle. Enfin, appelez validateConfig() en transmettant à 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 à permettre à davantage de délégués d'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 du processeur 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 la manière dont vous souhaitez que le service d'accélération évalue les inférences. Vous les utiliserez pour réussir :
- des échantillons d'entrée,
- résultats attendus,
- logique de validation de la précision.
Assurez-vous de fournir des échantillons d'entrée pour lesquels vous attendez de bonnes performances de votre modèle (également appelés échantillons « en 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 dorés avec setBatchSize() . Transmettez les entrées de vos échantillons dorés en utilisant 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 adaptée à 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 Golden sont facultatives et tant que vous fournissez des entrées Golden, le service d'accélération peut générer en interne les sorties Golden. 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 le runtime TensorFlow Lite avec 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 passant un objet Iterable<AccelerationConfig> en tant que paramètre.
validateConfig() renverra une Task< ValidatedAccelerationConfigResult > à partir 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 comme configuration d'accélération pour votre interpréteur interpreterOptions.setAccelerationConfig() .
Mise en cache des configurations
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 d'application
Pour examiner une intégration in situ du service d'accélération, jetez un œil à 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 prend uniquement en charge TensorFlow Lite dans les services Google Play et vous ne pouvez pas l'utiliser si vous utilisez la version fournie 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. - Le SDK du service d’accélération prend uniquement en charge le niveau d’API 22 et supérieur.
Mises en garde
Veuillez lire attentivement les mises en garde suivantes, surtout 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 envoyer une mise à jour de votre application en temps opportun. Ne pas le faire pourrait entraîner des pannes, car le SDK bêta pourrait 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 de l'API du service d'accélération 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'API elle-même pourraient é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 de Google .
De plus, les API du service d'accélération sont actuellement en version bêta et, en tant que telle, 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 entièrement sur l'appareil, et le service d'accélération n'envoie pas ces données aux serveurs de 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 Google de temps à autre afin de recevoir des éléments tels que des corrections 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 de votre application. Google utilise ces données de métriques pour mesurer les performances, déboguer, maintenir et améliorer les API, et détecter les utilisations inappropriées ou abusives, comme décrit plus en détail dans notre Politique de confidentialité .
Vous êtes responsable d'informer les utilisateurs de votre application sur le traitement par Google des données de métriques du service d'accélération, comme l'exige la loi applicable.
Les données que nous collectons comprennent les suivantes :
- Informations sur l'appareil (telles que le fabricant, le modèle, la version et la version du système d'exploitation) et 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 bundle, 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 initialisation, téléchargement de modèle, mise à jour, exécution, 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 de l'analyse de l'utilisation.
- Adresses IP de l’expéditeur de la demande réseau. Utilisé pour les diagnostics de configuration à distance. Les adresses IP collectées sont conservées temporairement.
Assistance et commentaires
Vous pouvez fournir des commentaires et obtenir de l'aide via TensorFlow Issue Tracker. 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.