TensorFlow est de retour sur Google I/O le 14 mai ! S'inscrire maintenant

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

Reconnaissance de sons et de mots pour Android

Ce didacticiel vous montre comment utiliser TensorFlow Lite avec des modèles d'apprentissage automatique prédéfinis pour reconnaître les sons et les mots prononcés dans une application Android. Les modèles de classification audio comme ceux présentés dans ce didacticiel peuvent être utilisés pour détecter une activité, identifier des actions ou reconnaître des commandes vocales.

Démo animée de reconnaissance audio Ce didacticiel vous montre comment télécharger l'exemple de code, charger le projet dans Android Studio et explique les éléments clés de l'exemple de code afin que vous puissiez commencer à ajouter cette fonctionnalité à votre propre application. L'exemple de code d'application utilise la bibliothèque de tâches TensorFlow pour l'audio , qui gère la plupart de l'enregistrement et du prétraitement des données audio. Pour plus d'informations sur la façon dont l'audio est prétraité pour être utilisé avec des modèles d'apprentissage automatique, consultez Préparation et augmentation des données audio .

Classification audio avec apprentissage automatique

Le modèle d'apprentissage automatique de ce didacticiel reconnaît les sons ou les mots d'échantillons audio enregistrés avec un microphone sur un appareil Android. L'exemple d'application de ce didacticiel vous permet de basculer entre YAMNet/classifier , un modèle qui reconnaît les sons, et un modèle qui reconnaît des mots prononcés spécifiques, qui a été entraîné à l'aide de l'outil TensorFlow Lite Model Maker . Les modèles exécutent des prédictions sur des clips audio contenant 15 600 échantillons individuels par clip et d’une durée d’environ 1 seconde.

Exemple d'installation et d'exécution

Pour la première partie de ce didacticiel, vous téléchargez l'exemple depuis GitHub et l'exécutez à l'aide d'Android Studio. Les sections suivantes de ce didacticiel explorent les sections pertinentes de l'exemple afin que vous puissiez les appliquer à vos propres applications Android.

Configuration requise

Android Studio version 2021.1.1 (Bumblebee) ou supérieure.
SDK Android version 31 ou supérieure
Appareil Android avec une version minimale du système d'exploitation du SDK 24 (Android 7.0 - Nougat) avec le mode développeur activé.

Obtenez l'exemple de code

Créez une copie locale de l'exemple de code. Vous utiliserez ce code pour créer un projet dans Android Studio et exécuter l'exemple d'application.

Pour cloner et configurer l'exemple de code :

Cloner le dépôt git

git clone https://github.com/tensorflow/examples.git

Vous pouvez éventuellement configurer votre instance git pour utiliser une extraction fragmentée afin de disposer uniquement des fichiers de l'exemple d'application :
```
cd examples
git sparse-checkout init --cone
git sparse-checkout set lite/examples/audio_classification/android
```

Importer et exécuter le projet

Créez un projet à partir de l'exemple de code téléchargé, générez le projet, puis exécutez-le.

Pour importer et créer l'exemple de projet de code :

Démarrez Android Studio .
Dans Android Studio, choisissez Fichier > Nouveau > Importer un projet .
Accédez au répertoire de code d'exemple contenant le fichier build.gradle ( .../examples/lite/examples/audio_classification/android/build.gradle ) et sélectionnez ce répertoire.

Si vous sélectionnez le bon répertoire, Android Studio crée un nouveau projet et le construit. Ce processus peut prendre quelques minutes, selon la vitesse de votre ordinateur et si vous avez utilisé Android Studio pour d'autres projets. Une fois la construction terminée, Android Studio affiche un message BUILD SUCCESSFUL dans le panneau d'état de sortie de construction .

Pour exécuter le projet :

Depuis Android Studio, exécutez le projet en sélectionnant Exécuter > Exécuter 'app' .
Sélectionnez un appareil Android connecté avec un microphone pour tester l'application.

Les sections suivantes vous montrent les modifications que vous devez apporter à votre projet existant pour ajouter cette fonctionnalité à votre propre application, en utilisant cet exemple d'application comme point de référence.

Ajouter des dépendances de projet

Dans votre propre application, vous devez ajouter des dépendances de projet spécifiques pour exécuter des modèles d'apprentissage automatique TensorFlow Lite et accéder aux fonctions utilitaires qui convertissent les formats de données standard, tels que l'audio, en un format de données tensoriel pouvant être traité par le modèle que vous utilisez.

L'exemple d'application utilise les bibliothèques TensorFlow Lite suivantes :

API audio de la bibliothèque de tâches TensorFlow Lite : fournit les classes d'entrée de données audio requises, l'exécution du modèle d'apprentissage automatique et les résultats de sortie du traitement du modèle.

Les instructions suivantes montrent comment ajouter les dépendances de projet requises à votre propre projet d'application Android.

Pour ajouter des dépendances de module :

Dans le module qui utilise TensorFlow Lite, mettez à jour le fichier build.gradle du module pour inclure les dépendances suivantes. Dans l'exemple de code, ce fichier se trouve ici : .../examples/lite/examples/audio_classification/android/build.gradle
```
dependencies {
...
    implementation 'org.tensorflow:tensorflow-lite-task-audio'
}
```
Dans Android Studio, synchronisez les dépendances du projet en sélectionnant : Fichier > Synchroniser le projet avec les fichiers Gradle .

Initialiser le modèle ML

Dans votre application Android, vous devez initialiser le modèle de machine learning TensorFlow Lite avec des paramètres avant d'exécuter des prédictions avec le modèle. Ces paramètres d'initialisation dépendent du modèle et peuvent inclure des paramètres tels que des seuils de précision minimaux par défaut pour les prédictions et des étiquettes pour les mots ou les sons que le modèle peut reconnaître.

Un modèle TensorFlow Lite inclut un fichier *.tflite contenant le modèle. Le fichier modèle contient la logique de prédiction et inclut généralement des métadonnées sur la manière d'interpréter les résultats de prédiction, telles que les noms des classes de prédiction. Les fichiers de modèle doivent être stockés dans le répertoire src/main/assets de votre projet de développement, comme dans l'exemple de code :

<project>/src/main/assets/yamnet.tflite

Pour plus de commodité et de lisibilité du code, l'exemple déclare un objet compagnon qui définit les paramètres du modèle.

Pour initialiser le modèle dans votre application :

Créez un objet compagnon pour définir les paramètres du modèle :

companion object {
  const val DISPLAY_THRESHOLD = 0.3f
  const val DEFAULT_NUM_OF_RESULTS = 2
  const val DEFAULT_OVERLAP_VALUE = 0.5f
  const val YAMNET_MODEL = "yamnet.tflite"
  const val SPEECH_COMMAND_MODEL = "speech.tflite"
}

Créez les paramètres du modèle en créant un objet AudioClassifier.AudioClassifierOptions :

val options = AudioClassifier.AudioClassifierOptions.builder()
  .setScoreThreshold(classificationThreshold)
  .setMaxResults(numOfResults)
  .setBaseOptions(baseOptionsBuilder.build())
  .build()

Utilisez cet objet de paramètres pour créer un objet TensorFlow Lite AudioClassifier qui contient le modèle :
```
classifier = AudioClassifier.createFromFileAndOptions(context, "yamnet.tflite", options)
```

Activer l'accélération matérielle

Lors de l'initialisation d'un modèle TensorFlow Lite dans votre application, vous devez envisager d'utiliser les fonctionnalités d'accélération matérielle pour accélérer les calculs de prédiction du modèle. Les délégués TensorFlow Lite sont des modules logiciels qui accélèrent l'exécution de modèles d'apprentissage automatique à l'aide de matériel de traitement spécialisé sur un appareil mobile, tel qu'une unité de traitement graphique (GPU) ou des unités de traitement tensoriel (TPU). L'exemple de code utilise le délégué NNAPI pour gérer l'accélération matérielle de l'exécution du modèle :

val baseOptionsBuilder = BaseOptions.builder()
   .setNumThreads(numThreads)
...
when (currentDelegate) {
   DELEGATE_CPU -> {
       // Default
   }
   DELEGATE_NNAPI -> {
       baseOptionsBuilder.useNnapi()
   }
}

L'utilisation de délégués pour exécuter des modèles TensorFlow Lite est recommandée, mais pas obligatoire. Pour plus d'informations sur l'utilisation de délégués avec TensorFlow Lite, consultez Délégués TensorFlow Lite .

Préparer les données pour le modèle

Dans votre application Android, votre code fournit des données au modèle à des fins d'interprétation en transformant les données existantes telles que des clips audio en un format de données Tensor pouvant être traité par votre modèle. Les données d'un Tensor que vous transmettez à un modèle doivent avoir des dimensions ou une forme spécifiques qui correspondent au format des données utilisées pour entraîner le modèle.

Le modèle YAMNet/classificateur et les modèles de commandes vocales personnalisées utilisés dans cet exemple de code acceptent les objets de données Tensor qui représentent des clips audio monocanaux ou mono enregistrés à 16 kHz en clips de 0,975 seconde (15 600 échantillons). En exécutant des prédictions sur de nouvelles données audio, votre application doit transformer ces données audio en objets de données Tensor de cette taille et de cette forme. L' API audio de la bibliothèque de tâches TensorFlow Lite gère la transformation des données pour vous.

Dans l’exemple de code de classe AudioClassificationHelper , l’application enregistre l’audio en direct des microphones de l’appareil à l’aide d’un objet Android AudioRecord . Le code utilise AudioClassifier pour créer et configurer cet objet afin d'enregistrer l'audio à une fréquence d'échantillonnage appropriée pour le modèle. Le code utilise également AudioClassifier pour créer un objet TensorAudio afin de stocker les données audio transformées. Ensuite, l'objet TensorAudio est transmis au modèle pour analyse.

Pour fournir des données audio au modèle ML :

Utilisez l'objet AudioClassifier pour créer un objet TensorAudio et un objet AudioRecord :

fun initClassifier() {
...
  try {
    classifier = AudioClassifier.createFromFileAndOptions(context, currentModel, options)
    // create audio input objects
    tensorAudio = classifier.createInputTensorAudio()
    recorder = classifier.createAudioRecord()
  }

Exécuter des prédictions

Dans votre application Android, une fois que vous avez connecté un objet AudioRecord et un objet TensorAudio à un objet AudioClassifier, vous pouvez exécuter le modèle sur ces données pour produire une prédiction ou une inférence . L'exemple de code de ce didacticiel exécute des prédictions sur les clips d'un flux d'entrée audio enregistré en direct à une fréquence spécifique.

L'exécution du modèle consomme des ressources importantes. Il est donc important d'exécuter les prédictions du modèle ML sur un thread d'arrière-plan distinct. L'exemple d'application utilise un objet [ScheduledThreadPoolExecutor](https://developer.android.com/reference/java/util/concurrent/ScheduledThreadPoolExecutor) pour isoler le traitement du modèle des autres fonctions de l'application.

Les modèles de classification audio qui reconnaissent les sons ayant un début et une fin clairs, comme les mots, peuvent produire des prédictions plus précises sur un flux audio entrant en analysant des clips audio qui se chevauchent. Cette approche aide le modèle à éviter de manquer des prédictions pour les mots coupés à la fin d'un clip. Dans l'exemple d'application, chaque fois que vous exécutez une prédiction, le code récupère le dernier clip de 0,975 seconde du tampon d'enregistrement audio et l'analyse. Vous pouvez faire en sorte que le modèle analyse des clips audio qui se chevauchent en définissant la valeur de interval du pool d'exécution du thread d'analyse du modèle sur une longueur plus courte que la longueur des clips analysés. Par exemple, si votre modèle analyse des clips d'une seconde et que vous définissez l'intervalle sur 500 millisecondes, le modèle analysera la dernière moitié du clip précédent et 500 millisecondes de nouvelles données audio à chaque fois, créant ainsi un chevauchement d'analyse de clip de 50 %.

Pour commencer à exécuter des prédictions sur les données audio :

Utilisez la méthode AudioClassificationHelper.startAudioClassification() pour démarrer l'enregistrement audio du modèle :

fun startAudioClassification() {
  if (recorder.recordingState == AudioRecord.RECORDSTATE_RECORDING) {
    return
  }
  recorder.startRecording()
}

Définissez la fréquence à laquelle le modèle génère une inférence à partir des clips audio en définissant un interval de fréquence fixe dans l'objet ScheduledThreadPoolExecutor :
```
executor = ScheduledThreadPoolExecutor(1)
executor.scheduleAtFixedRate(
  classifyRunnable,
  0,
  interval,
  TimeUnit.MILLISECONDS)
```
L'objet classifyRunnable dans le code ci-dessus exécute la méthode AudioClassificationHelper.classifyAudio() , qui charge les dernières données audio disponibles à partir de l'enregistreur et effectue une prédiction :
```
private fun classifyAudio() {
  tensorAudio.load(recorder)
  val output = classifier.classify(tensorAudio)
  ...
}
```

Arrêter le traitement des prédictions

Assurez-vous que le code de votre application cesse d'effectuer la classification audio lorsque le fragment ou l'activité de traitement audio de votre application perd le focus. L'exécution continue d'un modèle d'apprentissage automatique a un impact significatif sur la durée de vie de la batterie d'un appareil Android. Utilisez la méthode onPause() de l'activité ou du fragment Android associé à la classification audio pour arrêter l'enregistrement audio et le traitement de prédiction.

Pour arrêter l'enregistrement audio et la classification :

Utilisez la méthode AudioClassificationHelper.stopAudioClassification() pour arrêter l'enregistrement et l'exécution du modèle, comme indiqué ci-dessous dans la classe AudioFragment :
```
override fun onPause() {
  super.onPause()
  if (::audioHelper.isInitialized ) {
    audioHelper.stopAudioClassification()
  }
}
```

Gérer la sortie du modèle

Dans votre application Android, après avoir traité un clip audio, le modèle produit une liste de prédictions que le code de votre application doit gérer en exécutant une logique métier supplémentaire, en affichant les résultats à l'utilisateur ou en effectuant d'autres actions. Le résultat d'un modèle TensorFlow Lite donné varie en termes du nombre de prédictions qu'il produit (une ou plusieurs) et des informations descriptives pour chaque prédiction. Dans le cas des modèles de l'application exemple, les prédictions sont soit une liste de sons ou de mots reconnus. L'objet d'options AudioClassifier utilisé dans l'exemple de code vous permet de définir le nombre maximum de prédictions avec la méthode setMaxResults() , comme indiqué dans la section Initialiser le modèle ML .

Pour obtenir les résultats de prédiction du modèle :

Obtenez les résultats de la méthode classify() de l'objet AudioClassifier et transmettez-les à l'objet écouteur (référence du code) :

private fun classifyAudio() {
  ...
  val output = classifier.classify(tensorAudio)
  listener.onResult(output[0].categories, inferenceTime)
}

Utilisez la fonction onResult() de l'écouteur pour gérer la sortie en exécutant la logique métier ou en affichant les résultats à l'utilisateur :

private val audioClassificationListener = object : AudioClassificationListener {
  override fun onResult(results: List<Category>, inferenceTime: Long) {
    requireActivity().runOnUiThread {
      adapter.categoryList = results
      adapter.notifyDataSetChanged()
      fragmentAudioBinding.bottomSheetLayout.inferenceTimeVal.text =
        String.format("%d ms", inferenceTime)
    }
  }

Le modèle utilisé dans cet exemple génère une liste de prédictions avec une étiquette pour le son ou le mot classé, et un score de prédiction compris entre 0 et 1 sous forme de flotteur représentant la confiance de la prédiction, 1 étant l'indice de confiance le plus élevé. En général, les prédictions avec un score inférieur à 50 % (0,5) sont considérées comme non concluantes. Toutefois, la manière dont vous gérez les résultats de prédiction de faible valeur dépend de vous et des besoins de votre application.

Une fois que le modèle a renvoyé un ensemble de résultats de prédiction, votre application peut agir sur ces prédictions en présentant le résultat à votre utilisateur ou en exécutant une logique supplémentaire. Dans le cas de l'exemple de code, l'application répertorie les sons ou les mots identifiés dans l'interface utilisateur de l'application.

Prochaines étapes

Vous pouvez trouver des modèles TensorFlow Lite supplémentaires pour le traitement audio sur TensorFlow Hub et via la page de guide des modèles pré-entraînés . Pour plus d'informations sur la mise en œuvre du machine learning dans votre application mobile avec TensorFlow Lite, consultez le Guide du développeur TensorFlow Lite .