Guide de classification audio pour Android

La tâche de classificateur audio MediaPipe vous permet d'effectuer une classification sur des données audio. Vous pouvez utiliser cette tâche pour identifier les événements sonores à partir d'un ensemble de catégories entraînées. Ces instructions vous expliquent comment utiliser le classificateur audio avec des applications Android.

Pour en savoir plus sur les fonctionnalités, les modèles et les options de configuration de cette tâche, consultez la présentation.

Exemple de code

L'exemple de code de tâches MediaPipe est une implémentation simple d'une application de classificateur audio pour Android. L'exemple utilise le micro d'un appareil Android physique pour classer en permanence les sons et peut également exécuter le classificateur sur les fichiers audio stockés sur l'appareil.

Vous pouvez utiliser l'application comme point de départ pour votre propre application Android ou vous y référer lorsque vous modifiez une application existante. L'exemple de code du classificateur audio est hébergé sur GitHub.

Télécharger le code

Les instructions suivantes vous expliquent comment créer une copie locale de l'exemple de code à l'aide de l'outil de ligne de commande git.

Pour télécharger l'exemple de code, procédez comme suit:

1. Clonez le dépôt git à l'aide de la commande suivante :

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

2. Vous pouvez éventuellement configurer votre instance Git pour utiliser le paiement creux afin de n'avoir que les fichiers de l'application exemple de classificateur audio :

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/audio_classifier/android
   

Après avoir créé une version locale de l'exemple de code, vous pouvez importer le projet dans Android Studio et exécuter l'application. Pour obtenir des instructions, consultez le guide de configuration pour Android.

Composants clés

Les fichiers suivants contiennent le code crucial pour cet exemple d'application de classification audio:

• AudioClassifierHelper.kt : initialise le classificateur audio, et gère le modèle et la sélection des délégués.
• RecorderFragment.kt : crée l'interface utilisateur et le code de contrôle pour l'enregistrement audio en direct.
• LibraryFragment.kt : crée l'interface utilisateur et le code de contrôle pour la sélection des fichiers audio.
• ProbabilitiesAdapter.kt : gère et met en forme les résultats de prédiction du classificateur.

Préparation

Cette section décrit les étapes clés pour configurer votre environnement de développement et vos projets de code spécifiquement pour l'utilisation du classificateur audio. Pour obtenir des informations générales sur la configuration de votre environnement de développement pour l'utilisation des tâches MediaPipe, y compris sur les exigences de version de la plate-forme, consultez le guide de configuration pour Android.

Dépendances

Le classificateur audio utilise la bibliothèque com.google.mediapipe:tasks-audio. Ajoutez cette dépendance au fichier build.gradle de votre projet de développement d'application Android. Importez les dépendances requises à l'aide du code suivant:

dependencies {
    ...
    implementation 'com.google.mediapipe:tasks-audio:latest.release'
}

Modèle

La tâche de classificateur audio MediaPipe nécessite un modèle entraîné compatible avec cette tâche. Pour en savoir plus sur les modèles entraînés disponibles pour le classificateur audio, consultez la section Modèles de la présentation des tâches.

Sélectionnez et téléchargez le modèle, puis stockez-le dans le répertoire de votre projet:

<dev-project-root>/src/main/assets

Utilisez la méthode BaseOptions.Builder.setModelAssetPath() pour spécifier le chemin d'accès utilisé par le modèle. Cette méthode est référencée dans l'exemple de code de la section suivante.

Dans l'exemple de code du classificateur audio, le modèle est défini dans le fichier AudioClassifierHelper.kt.

Créer la tâche

Vous pouvez utiliser la fonction createFromOptions pour créer la tâche. La fonction createFromOptions accepte des options de configuration telles que le mode d'exécution, les paramètres régionaux des noms à afficher, le nombre maximal de résultats, le seuil de confiance et une liste d'autorisation ou de refus de catégorie. Pour en savoir plus sur les options de configuration, consultez la section Présentation de la configuration.

La tâche de classificateur audio accepte les types de données d'entrée suivants: clips audio et flux audio. Vous devez spécifier le mode d'exécution correspondant à votre type de données d'entrée lors de la création d'une tâche. Choisissez l'onglet correspondant à votre type de données d'entrée pour voir comment créer la tâche et exécuter l'inférence.

AudioClassifierOptions options =
    AudioClassifierOptions.builder()
        .setBaseOptions(
            BaseOptions.builder().setModelAssetPath("model.tflite").build())
        .setRunningMode(RunningMode.AUDIO_CLIPS)
        .setMaxResults(5)
        .build();
audioClassifier = AudioClassifier.createFromOptions(context, options);
    

AudioClassifierOptions options =
    AudioClassifierOptions.builder()
        .setBaseOptions(
            BaseOptions.builder().setModelAssetPath("model.tflite").build())
        .setRunningMode(RunningMode.AUDIO_STREAM)
        .setMaxResults(5)
        .setResultListener(audioClassifierResult -> {
             // Process the classification result here.
        })
        .build();
audioClassifier = AudioClassifier.createFromOptions(context, options);
    

L'exemple de code du classificateur audio permet à l'utilisateur de basculer entre les modes de traitement. Cette approche complique le code de création de la tâche et peut ne pas être adaptée à votre cas d'utilisation. Vous pouvez voir le code de changement de mode dans la fonction initClassifier() de AudioClassifierHelper.

Options de configuration

Cette tâche dispose des options de configuration suivantes pour les applications Android:

Préparation des données

Le classificateur audio fonctionne avec des clips audio et des flux audio. La tâche gère le prétraitement des entrées de données, y compris le rééchantillonnage, la mise en mémoire tampon et le cadrage. Toutefois, vous devez convertir les données audio d'entrée en objet com.google.mediapipe.tasks.components.containers.AudioData avant de les transmettre à la tâche de classificateur audio.

import com.google.mediapipe.tasks.components.containers.AudioData;

// Load an audio on the user’s device as a float array.

// Convert a float array to a MediaPipe’s AudioData object.
AudioData audioData =
    AudioData.create(
        AudioData.AudioDataFormat.builder()
            .setNumOfChannels(numOfChannels)
            .setSampleRate(sampleRate)
            .build(),
        floatData.length);
audioData.load(floatData);
    

import android.media.AudioRecord;
import com.google.mediapipe.tasks.components.containers.AudioData;

AudioRecord audioRecord =
    audioClassifier.createAudioRecord(/* numChannels= */ 1, /* sampleRate= */ 16000);
audioRecord.startRecording();

...

// To get a one second clip from the AudioRecord object:
AudioData audioData =
    AudioData.create(
        16000 /*sample counts per second*/);
        AudioData.AudioDataFormat.create(audioRecord.getFormat()),
audioData.load(audioRecord)
    

Exécuter la tâche

Vous pouvez appeler la fonction classify correspondant à votre mode d'exécution pour déclencher des inférences. L'API Audio Classifier renvoie les catégories possibles pour les événements audio reconnus dans les données audio d'entrée.

AudioClassifierResult classifierResult = audioClassifier.classify(audioData);
    

// Run inference on the audio block. The classifications results will be available
// via the `resultListener` provided in the `AudioClassifierOptions` when
// the audio classifier was created.
audioClassifier.classifyAsync(audioBlock, timestampMs);
    

Veuillez noter les points suivants :

• Lors de l'exécution en mode de flux audio, vous devez également fournir à la tâche de classificateur audio un horodatage pour suivre quelles données audio du flux ont été utilisées pour l'inférence.
• Lors de l'exécution dans le modèle de clips audio, la tâche de classificateur audio bloque le thread actuel jusqu'à ce qu'il ait fini de traiter l'audio d'entrée. Pour éviter de bloquer les réponses de l'interface utilisateur, exécutez le traitement dans un thread d'arrière-plan.

Pour voir un exemple d'exécution du classificateur audio avec des extraits audio, consultez la classe AudioClassifierHelper dans l'exemple de code.

Gérer et afficher les résultats

Après avoir exécuté une inférence, la tâche de classificateur audio renvoie une liste de catégories possibles pour les événements audio dans les données audio d'entrée. La liste suivante montre un exemple de données de sortie de cette tâche:

AudioClassifierResult:
  Timestamp in microseconds: 100
  ClassificationResult #0:
    Timestamp in microseconds: 100  
    Classifications #0 (single classification head):
      head index: 0
      category #0:
        category name: "Speech"
        score: 0.6
        index: 0
      category #1:
        category name: "Music"
        score: 0.2
        index: 1

Dans une application Android, la tâche renvoie un ClassificationResult contenant une liste d'objets AudioClassifierResult représentant les prédictions pour un événement audio, y compris le libellé de catégorie et le score de confiance.

// In the audio clips mode, the classification results are for the entire audio
// clip. The results are timestamped AudioClassifierResult objects, each
// classifying an interval of the entire audio clip that starts at
// ClassificationResult.timestampMs().get().

for (ClassificationResult result : audioClassifierResult.classificationResults()) {
  // Audio interval start timestamp:
  result.timestampMs().get();
  // Classification result of the audio interval.
  result.classifications();
}
    

// In the audio stream mode, the classification results list only contains one
// element, representing the classification result of the audio block that
// starts at ClassificationResult.timestampMs in the audio stream.

ClassificationResult result = audioClassifierResult.classificationResults().get(0);
// The audio block start timestamp
audioClassifierResult.timestampMs();
// Alternatively, the same timestamp can be retrieved from
// result.timestampMs().get();

// Classification result.
result.classifications();
    

Vous trouverez un exemple d'affichage des résultats de classification renvoyés par cette tâche dans la classe ProbabilitiesAdapter de l'exemple de code.