Présentation de LiteRT: l'environnement d'exécution Google hautes performances pour l'IA sur l'appareil, anciennement connu sous le nom de TensorFlow Lite.

Cette page a été traduite par l'API Cloud Translation.

Service d'accélération pour Android (bêta)

Utilisation de processeurs spécialisés tels que des GPU, des NPU ou des DSP pour le matériel peut améliorer considérablement les performances d'inférence (jusqu'à 10 fois plus vite (inférence dans certains cas) et l'expérience utilisateur de votre application Android compatible avec le ML application. Cependant, compte tenu de la variété du matériel et des pilotes que vos utilisateurs peuvent choisir la configuration d'accélération matérielle optimale pour chaque appareil peut être difficile. De plus, l'activation de la mauvaise configuration appareil peut nuire à l'expérience utilisateur en raison d'une latence élevée ou, dans de rares cas, les erreurs d'exécution ou les problèmes de précision provoqués par des incompatibilités matérielles.

Le service d'accélération pour Android est une API qui vous aide à choisir une configuration d'accélération matérielle optimale pour l'appareil d'un utilisateur donné et votre .tflite, tout en minimisant le risque d'erreur d'exécution ou de problèmes de justesse.

Le service d'accélération évalue différentes configurations d'accélération sur l'utilisateur en exécutant des analyses comparatives d'inférence internes avec votre système LiteRT du modèle. Ces tests s'exécutent généralement en quelques secondes, en fonction du modèle. Vous pouvez exécuter les analyses comparatives une fois sur chaque appareil de chaque utilisateur avant 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 réduit le risque de plantages de votre application.

Fournissez votre modèle, des échantillons de données et les résultats attendus (entrées "golden" et résultats) et le service d'accélération exécute une 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 LiteRT 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 du service d'accélération fonctionne avec LiteRT dans Google Play Services. Si vous n'utilisez pas encore l'environnement d'exécution LiteRT fourni par les services Play, vous devrez mettre à jour vos dependencies.

Utiliser l'API Acceleration Service

Pour utiliser le service d'accélération, commencez par créer la configuration d'accélération à évaluer pour votre modèle (par exemple, un GPU avec OpenGL). Créez ensuite un configuration de validation avec votre modèle, quelques exemples de données et la sortie du modèle. Enfin, appelez validateConfig() en transmettant à la fois votre la configuration de l'accélération et de la 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 traduits en délégués pendant l'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 le GPU (converties en délégué de GPU pendant la durée d'exécution) avec le GpuAccelerationConfig et l'inférence CPU (avec CpuAccelerationConfig). Nous nous efforçons de permettre à davantage de délégués d'accéder à d'autres matériels dans le à venir.

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 une 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 le setNumThreads() permettant de définir le nombre de threads à utiliser pour évaluer le CPU l'inférence.

Créer des configurations de validation

Les configurations de validation vous permettent de définir la manière Service permettant d'évaluer les inférences Vous les utiliserez pour transmettre les éléments suivants:

des échantillons d'entrée,
les résultats attendus,
de validation de la justesse.

Veillez à fournir des exemples d'entrées pour lesquels vous attendez de bonnes performances votre modèle (également appelés échantillons "golden").

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() Transmettre les entrées de vos échantillons clés à l'aide de setGoldenInputs() Fournissez le résultat attendu pour l'entrée transmise avec setGoldenOutputs()

Vous pouvez définir une durée d'inférence maximale 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 rejetée.

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;

   }
}

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. Tant que vous fournissez ces entrées, Le service d'accélération peut générer en interne les sorties clés. Vous pouvez également définir la configuration d'accélération utilisée pour générer ces résultats clés nous appelons 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 LiteRT avec les services Play est correct initialisé et que le délégué de 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 une Task<ValidatedAccelerationConfigResult> depuis les services Google Play l'API Task, qui active des tâches asynchrones.
Pour obtenir le résultat de l'appel de validation, ajoutez un addOnSuccessListener() .

Utiliser une configuration validée dans votre interpréteur

Après avoir vérifié si ValidatedAccelerationConfigResult est renvoyé dans est valide, vous pouvez définir la configuration validée en tant que configuration d'accélération pour que votre interprète appelle 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 le l'appareil. Une fois que vous avez une configuration d'accélération satisfaisante, doit les stocker sur l'appareil et laisser votre application les récupérer et les utiliser pour créer votre InterpreterOptions lors des sessions suivantes au lieu de exécuter une autre validation. Les méthodes serialize() et deserialize() dans ValidatedAccelerationConfigResult assurent le processus de stockage et de récupération plus facile.

Exemple d'application

Pour examiner une intégration en situation du service d'accélération, consultez la 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.
Elle n'est compatible qu'avec LiteRT dans les services Google Play, et vous ne pouvez pas si vous utilisez la version intégrée de LiteRT.
Le SDK du service d'accélération n'est compatible qu'avec les niveaux d'API 22 et supérieurs.

Mises en garde

Veuillez lire attentivement les mises en garde suivantes, surtout si vous prévoyez pour utiliser ce SDK en production:

Avant de quitter la version bêta et de publier la version stable pour le l'API du service d'accélération, nous allons publier un nouveau SDK pouvant avoir différences par rapport à la version bêta actuelle. Pour continuer à utiliser service d'accélération, vous devez migrer vers ce nouveau SDK et transmettre une mise à jour rapide de votre application. Ne pas le faire peut causer des dysfonctionnements il est possible que le SDK bêta ne soit plus compatible avec les services Google Play après un certain temps.
Rien ne garantit qu'une fonctionnalité spécifique L'API Service ou l'API dans son ensemble seront accessibles à tous. Il peuvent rester en version bêta pour une durée indéterminée, être arrêtées ou combinées à d'autres dans des packages conçus pour des publics de développeurs spécifiques. Un peu avec l'API Acceleration Service ou l'API entière finiront par être en disponibilité générale, mais il n'y a pas de calendrier fixe pour cette étape.

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 d'assistance.
De plus, les API Acceleration Service sont actuellement en version bêta. Aussi, en l'utilisant, vous reconnaissez les problèmes potentiels décrits dans les Mises en garde ci-dessus et vous reconnaissez que le service d'accélération ne peut pas fonctionne toujours 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éos, texte) s'effectue intégralement sur l'appareil et le service d'accélération n'envoie pas ces données aux serveurs Google. Vous pouvez donc 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 dans pour recevoir des corrections de bugs, des mises à jour de modèles et un accélérateur matériel des informations sur la compatibilité. Les API du service d'accélération envoient aussi des métriques les performances et l'utilisation des API de votre appli à Google. Google utilise ces données métriques pour mesurer les performances, déboguer, gérer et améliorer les API, et détecter les usages abusifs ou abusifs, comme décrit plus en détail dans nos Règles de confidentialité Règlement.
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 comprennent les éléments suivants:

Informations sur l'appareil (fabricant, modèle, version de l'OS et build) les accélérateurs matériels de ML (GPU et DSP) disponibles. Utilisé pour les diagnostics et et l'analyse de l'utilisation.
Informations sur l'application (nom du package / ID du bundle, version de l'application) Utilisation les diagnostics et les analyses d'utilisation.
Configuration de l'API (format d'image et résolution, par exemple). Utilisation les diagnostics et les analyses d'utilisation.
Type d'événement (initialisation, téléchargement du modèle, mise à jour, exécution, détection, par exemple) Utilisé pour les diagnostics et les analyses d'utilisation.
Codes d'erreur. Utilisé pour les diagnostics.
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 et de l'utilisation à distance analyse.
Adresses IP de l'expéditeur de la requête réseau. Utilisé pour la configuration à distance de l'infrastructure. 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 Issue Tracker de TensorFlow. Veuillez signaler tout problème ou toute demande d'assistance via le modèle de problème pour LiteRT dans les services Google Play.