L'utilisation de processeurs spécialisés tels que des GPU, des NPU ou des DSP pour l'accélération matérielle peut améliorer considérablement les performances d'inférence (jusqu'à 10 fois plus rapides dans certains cas) et l'expérience utilisateur de votre application Android compatible avec le ML. Toutefois, étant donné la variété de matériel et de pilotes dont vos utilisateurs peuvent disposer, il peut être difficile de choisir la configuration d'accélération matérielle optimale pour chaque appareil. En outre, l'activation d'une mauvaise configuration sur un appareil peut nuire à l'expérience utilisateur en raison d'une latence élevée ou, dans certains cas rares, d'erreurs d'exécution ou de problèmes de précision dus à des incompatibilités matérielles.
Le service d'accélération 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 réduisant le risque d'erreur d'exécution ou de problème 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 benchmarks d'inférence internes avec votre modèle TensorFlow Lite. Ces exécutions de test prennent généralement quelques secondes en fonction de votre modèle. Vous pouvez exécuter les analyses comparatives une fois sur chaque appareil de l'utilisateur avant l'inférence, mettre en cache le résultat et l'utiliser lors de l'inférence. Ces benchmarks sont hors processus, ce qui réduit le risque de plantages de votre application.
Fournissez votre modèle, des échantillons de données et des résultats attendus (entrées et sorties "golden"). Le service d'accélération exécutera alors un benchmark d'inférence TFLite interne pour vous fournir des recommandations matérielles.
Le service d'accélération fait partie de la pile de 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 les services Google Play. Si vous n'utilisez pas encore l'environnement d'exécution TensorFlow Lite fourni via les services Play, vous devrez mettre à jour vos dépendances.
Utiliser l'API Acceleration Service
Pour utiliser le service d'accélération, 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 attendue du modèle. Enfin, appelez validateConfig() en transmettant 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 converties 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.
À l'heure actuelle, le service d'accélération vous permet d'évaluer les configurations de GPU (converties en délégués de GPU pendant le temps d'exécution) à l'aide de GpuAccelerationConfig et d'inférences de processeur (avec CpuAccelerationConfig). Nous nous efforçons de permettre à davantage de délégués d'accéder à d'autres matériels à l'avenir.
Configuration de l'accélération du GPU
Créez une configuration d'accélération GPU comme suit:
AccelerationConfig accelerationConfig = new GpuAccelerationConfig.Builder()
.setEnableQuantizedInference(false)
.build();
Vous devez indiquer si votre modèle utilise 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 à utiliser pour évaluer l'inférence de processeur.
Créer des configurations de validation
Les configurations de validation vous permettent de définir la manière dont le service d'accélération doit évaluer les inférences. Vous les utiliserez pour transmettre:
- des échantillons d'entrée,
- les résultats attendus,
- logique de validation de la justesse.
Veillez à fournir des échantillons d'entrée pour lesquels vous attendez de bonnes performances de votre modèle (également appelés "échantillons de référence").
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 clés avec setBatchSize().
Transmettez les entrées de vos échantillons de référence à l'aide de setGoldenInputs().
Fournissez le résultat attendu pour l'entrée transmise avec setGoldenOutputs().
Vous pouvez définir un temps d'inférence maximal avec setInferenceTimeoutMillis() (5 000 ms par défaut). Si l'inférence dure plus longtemps que le temps que vous avez défini, la configuration sera refusée.
Vous pouvez également créer une AccuracyValidator personnalisée 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;
}
}
Veillez à 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 à votre modèle, vous pouvez utiliser EmbeddedValidationConfig.
Générer des sorties de validation
Les sorties de référence sont facultatives et, tant que vous fournissez des entrées clés, le service d'accélération peut les générer en interne. Vous pouvez également définir la configuration d'accélération utilisée pour générer ces résultats clés 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 avec les services Play est correctement initialisé et que le délégué GPU est disponible pour l'appareil en exécutant la commande suivante:
TfLiteGpu.isGpuDelegateAvailable(context)
.onSuccessTask(gpuAvailable -> TfLite.initialize(context,
TfLiteInitializationOptions.builder()
.setEnableGpuDelegateSupport(gpuAvailable)
.build()
)
);
Instanciez AccelerationService en appelant AccelerationService.create().
Vous pouvez ensuite valider la configuration d'accélération de 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() renvoie Task<ValidatedAccelerationConfigResult> à partir de l'API Tasks des services Google Play, qui active les tâches asynchrones.
Pour obtenir le résultat de l'appel de validation, ajoutez un rappel addOnSuccessListener().
Utiliser 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 avez reçu 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 votre 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 en situation du service d'accélération, consultez l'application exemple.
Limites
Le service d'accélération présente actuellement les limites suivantes:
- Seules les configurations d'accélération du processeur et du GPU sont acceptées pour le moment.
- Il n'est compatible qu'avec TensorFlow Lite dans les services Google Play, et vous ne pouvez pas l'utiliser si vous utilisez la version groupée de TensorFlow Lite.
- Le SDK Acceleration Service n'est compatible qu'avec le niveau d'API 22 ou supérieur.
Mises en garde
Veuillez lire attentivement les mises en garde suivantes, en particulier si vous prévoyez 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 des différences par rapport à la version bêta actuelle. Pour continuer à utiliser le service d'accélération, vous devez migrer vers ce nouveau SDK et déployer une mise à jour de votre application dans les meilleurs délais. Sinon, vous risquez de rencontrer des problèmes, car le SDK bêta risque de ne plus être compatible avec les services Google Play après un certain temps.
Rien ne garantit qu'une fonctionnalité spécifique de l'API Acceleration Service ou de l'API dans son ensemble sera un jour accessible à tous. Elle peut rester en version bêta indéfiniment, être arrêtée ou être combinée à d'autres fonctionnalités dans des packages conçus pour des audiences de développeurs spécifiques. Certaines fonctionnalités de l'API Acceleration Service ou de l'API entière elle-même pourront à terme devenir en disponibilité générale, mais aucune programmation fixe n'est définie.
Conditions d'utilisation et règles de 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. Par conséquent, en l'utilisant, vous reconnaissez les problèmes potentiels décrits dans la section "Mises en garde" ci-dessus et vous reconnaissez que le service d'accélération peut ne pas toujours fonctionner comme indiqué.
Confidentialité
Lorsque vous utilisez les API du service d'accélération, le traitement des données d'entrée (images, vidéos, texte, par exemple) est entièrement effectué sur l'appareil. 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 Google de temps en temps pour recevoir des éléments tels que des corrections de bugs, des mises à jour de modèles et des informations sur la compatibilité avec l'accélérateur matériel. 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, gérer et améliorer les API, et détecter les utilisations abusives, comme décrit plus en détail dans nos Règles de confidentialité.
Vous êtes tenu d'informer les utilisateurs de votre application du traitement par Google des données des métriques du service d'accélération, conformément à la législation applicable.
Les données que nous recueillons incluent les éléments suivants:
- Informations sur l'appareil (telles que le fabricant, le modèle, la version de l'OS et le build) et les accélérateurs matériels de ML disponibles (GPU et DSP). Utilisé pour les diagnostics et les analyses d'utilisation.
- Informations sur l'application (nom de package / ID de bundle, version de l'application) Utilisé pour les diagnostics et les analyses de l'utilisation.
- Configuration de l'API (format et résolution de l'image, par exemple). Utilisé pour les diagnostics et les analyses de l'utilisation.
- Type d'événement (initialisation, téléchargement du modèle, mise à jour, exécution, détection, etc.) Utilisé pour les diagnostics et les analyses d'utilisation.
- Codes d'erreur Utilisé pour les diagnostics.
- Les métriques de performances. Utilisé pour les diagnostics.
- 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 des analyses d'utilisation.
- Adresses IP des expéditeurs de requêtes réseau. Utilisé pour les diagnostics de configuration à distance. Les adresses IP collectées sont conservées temporairement.
Assistance et commentaires
Vous pouvez envoyer vos commentaires et obtenir de l'aide via l'outil de suivi des problèmes de 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.