Google I/O est terminé ! Suivez les sessions TensorFlow Afficher les sessions

Intégrer des classificateurs audio

La classification audio est un cas d'utilisation courant de Machine Learning pour classer les types de sons. Par exemple, il peut identifier les espèces d'oiseaux par leurs chants.

L'API Task Library AudioClassifier peut être utilisée pour déployer vos classificateurs audio personnalisés ou préformés dans votre application mobile.

Principales fonctionnalités de l'API AudioClassifier

  • Traitement de l'audio d'entrée, par exemple conversion du codage PCM 16 bits en codage PCM Float et manipulation du tampon circulaire audio.

  • Étiqueter les paramètres régionaux de la carte.

  • Prise en charge du modèle de classification multi-têtes.

  • Prend en charge la classification à étiquette unique et à étiquettes multiples.

  • Seuil de score pour filtrer les résultats.

  • Résultats de la classification Top-k.

  • Étiquetez la liste d'autorisation et la liste de refus.

Modèles de classificateurs audio pris en charge

Les modèles suivants sont garantis compatibles avec l'API AudioClassifier .

Exécuter l'inférence en Java

Voir l' application de référence Audio Classification pour un exemple utilisant AudioClassifier dans une application Android.

Étape 1 : Importer la dépendance Gradle et d'autres paramètres

Copiez le fichier de modèle .tflite dans le répertoire assets du module Android où le modèle sera exécuté. Spécifiez que le fichier ne doit pas être compressé et ajoutez la bibliothèque TensorFlow Lite au fichier build.gradle du module :

android {
    // Other settings

    // Specify that the tflite file should not be compressed when building the APK package.
    aaptOptions {
        noCompress "tflite"
    }
}

dependencies {
    // Other dependencies

    // Import the Audio Task Library dependency (NNAPI is included)
    implementation 'org.tensorflow:tensorflow-lite-task-audio:0.4.0'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.4.0'
}

Étape 2 : Utilisation du modèle

// Initialization
AudioClassifierOptions options =
    AudioClassifierOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setMaxResults(1)
        .build();
AudioClassifier classifier =
    AudioClassifier.createFromFileAndOptions(context, modelFile, options);

// Start recording
AudioRecord record = classifier.createAudioRecord();
record.startRecording();

// Load latest audio samples
TensorAudio audioTensor = classifier.createInputTensorAudio();
audioTensor.load(record);

// Run inference
List<Classifications> results = audioClassifier.classify(audioTensor);

Voir le code source et javadoc pour plus d'options pour configurer AudioClassifier .

Exécuter l'inférence en Python

Étape 1 : Installez le package pip

pip install tflite-support
  • Linux : exécutez sudo apt-get update && apt-get install libportaudio2
  • Mac et Windows : PortAudio est installé automatiquement lors de l'installation du package pip tflite-support .

Étape 2 : Utilisation du modèle

# Imports
from tflite_support.task import vision
from tflite_support.task import core
from tflite_support.task import processor

# Initialization
base_options = core.BaseOptions(file_name=model_path)
classification_options = processor.ClassificationOptions(max_results=2)
options = audio.AudioClassifierOptions(base_options=base_options, classification_options=classification_options)
classifier = audio.AudioClassifier.create_from_options(options)

# Alternatively, you can create an audio classifier in the following manner:
# classifier = audio.AudioClassifier.create_from_file(model_path)

# Run inference
audio_file = audio.TensorAudio.create_from_wav_file(audio_path, classifier.required_input_buffer_size)
audio_result = classifier.classify(audio_file)

Voir le code source pour plus d'options pour configurer AudioClassifier .

Exécuter l'inférence en C++

// Initialization
AudioClassifierOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_file);
std::unique_ptr<AudioClassifier> audio_classifier = AudioClassifier::CreateFromOptions(options).value();

// Create input audio buffer from data.
int input_buffer_size = audio_classifier->GetRequiredInputBufferSize();
const std::unique_ptr<AudioBuffer> audio_buffer =
    AudioBuffer::Create(audio_data.get(), input_buffer_size, kAudioFormat).value();

// Run inference
const ClassificationResult result = audio_classifier->Classify(*audio_buffer).value();

Voir le code source pour plus d'options pour configurer AudioClassifier .

Exigences de compatibilité des modèles

L'API AudioClassifier attend un modèle TFLite avec des métadonnées de modèle TFLite obligatoires. Consultez des exemples de création de métadonnées pour les classificateurs audio à l'aide de l' API TensorFlow Lite Metadata Writer .

Les modèles de classificateurs audio compatibles doivent répondre aux exigences suivantes :

  • Tenseur audio d'entrée (kTfLiteFloat32)

    • clip audio de taille [batch x samples] .
    • l'inférence par lot n'est pas prise en charge ( batch doit être égal à 1).
    • pour les modèles multicanaux, les canaux doivent être entrelacés.

  • Tenseur de score de sortie (kTfLiteFloat32)

    • [1 x N] avec N représentant le numéro de classe.
    • carte(s) d'étiquettes facultative (mais recommandée) en tant qu'AssociatedFile-s avec le type TENSOR_AXIS_LABELS, contenant une étiquette par ligne. Le premier AssociatedFile (le cas échéant) est utilisé pour remplir le champ d' label (nommé class_name en C++) des résultats. Le champ display_name est rempli à partir de l'AssociatedFile (le cas échéant) dont les paramètres régionaux correspondent au champ display_names_locale des AudioClassifierOptions utilisés au moment de la création ("en" par défaut, c'est-à-dire l'anglais). Si aucun de ceux-ci n'est disponible, seul le champ d' index des résultats sera rempli.