Assistez au symposium Women in ML le 7 décembre Inscrivez-vous maintenant

Intégrer des classificateurs audio

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

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 dans iOS

Étape 1 : Installer les dépendances

La bibliothèque de tâches prend en charge l'installation à l'aide de CocoaPods. Assurez-vous que CocoaPods est installé sur votre système. Veuillez consulter le guide d'installation de CocoaPods pour obtenir des instructions.

Veuillez consulter le guide CocoaPods pour plus de détails sur l'ajout de pods à un projet Xcode.

Ajoutez le pod TensorFlowLiteTaskAudio dans le Podfile.

target 'MyAppWithTaskAPI' do
  use_frameworks!
  pod 'TensorFlowLiteTaskAudio'
end

Assurez-vous que le modèle .tflite que vous utiliserez pour l'inférence est présent dans votre app bundle.

Étape 2 : Utilisation du modèle

Rapide

// Imports
import TensorFlowLiteTaskAudio
import AVFoundation

// Initialization
guard let modelPath = Bundle.main.path(forResource: "sound_classification",
                                            ofType: "tflite") else { return }

let options = AudioClassifierOptions(modelPath: modelPath)

// Configure any additional options:
// options.classificationOptions.maxResults = 3

let classifier = try AudioClassifier.classifier(options: options)

// Create Audio Tensor to hold the input audio samples which are to be classified.
// Created Audio Tensor has audio format matching the requirements of the audio classifier.
// For more details, please see:
// https://github.com/tensorflow/tflite-support/blob/master/tensorflow_lite_support/ios/task/audio/core/audio_tensor/sources/TFLAudioTensor.h
let audioTensor = classifier.createInputAudioTensor()

// Create Audio Record to record the incoming audio samples from the on-device microphone.
// Created Audio Record has audio format matching the requirements of the audio classifier.
// For more details, please see:
https://github.com/tensorflow/tflite-support/blob/master/tensorflow_lite_support/ios/task/audio/core/audio_record/sources/TFLAudioRecord.h
let audioRecord = try classifier.createAudioRecord()

// Request record permissions from AVAudioSession before invoking audioRecord.startRecording().
AVAudioSession.sharedInstance().requestRecordPermission { granted in
    if granted {
        DispatchQueue.main.async {
            // Start recording the incoming audio samples from the on-device microphone.
            try audioRecord.startRecording()

            // Load the samples currently held by the audio record buffer into the audio tensor.
            try audioTensor.load(audioRecord: audioRecord)

            // Run inference
            let classificationResult = try classifier.classify(audioTensor: audioTensor)
        }
    }
}

Objectif c

// Imports
#import <TensorFlowLiteTaskAudio/TensorFlowLiteTaskAudio.h>
#import <AVFoundation/AVFoundation.h>

// Initialization
NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"sound_classification" ofType:@"tflite"];

TFLAudioClassifierOptions *options =
    [[TFLAudioClassifierOptions alloc] initWithModelPath:modelPath];

// Configure any additional options:
// options.classificationOptions.maxResults = 3;

TFLAudioClassifier *classifier = [TFLAudioClassifier audioClassifierWithOptions:options
                                                                          error:nil];

// Create Audio Tensor to hold the input audio samples which are to be classified.
// Created Audio Tensor has audio format matching the requirements of the audio classifier.
// For more details, please see:
// https://github.com/tensorflow/tflite-support/blob/master/tensorflow_lite_support/ios/task/audio/core/audio_tensor/sources/TFLAudioTensor.h
TFLAudioTensor *audioTensor = [classifier createInputAudioTensor];

// Create Audio Record to record the incoming audio samples from the on-device microphone.
// Created Audio Record has audio format matching the requirements of the audio classifier.
// For more details, please see:
https://github.com/tensorflow/tflite-support/blob/master/tensorflow_lite_support/ios/task/audio/core/audio_record/sources/TFLAudioRecord.h
TFLAudioRecord *audioRecord = [classifier createAudioRecordWithError:nil];

// Request record permissions from AVAudioSession before invoking -[TFLAudioRecord startRecordingWithError:].
[[AVAudioSession sharedInstance] requestRecordPermission:^(BOOL granted) {
    if (granted) {
        dispatch_async(dispatch_get_main_queue(), ^{
            // Start recording the incoming audio samples from the on-device microphone.
            [audioRecord startRecordingWithError:nil];

            // Load the samples currently held by the audio record buffer into the audio tensor.
            [audioTensor loadAudioRecord:audioRecord withError:nil];

            // Run inference
            TFLClassificationResult *classificationResult =
                [classifier classifyWithAudioTensor:audioTensor error:nil];

        });
    }
}];

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

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 audio
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_path);
std::unique_ptr<AudioClassifier> audio_classifier = AudioClassifier::CreateFromOptions(options).value();

// Create input audio buffer from your `audio_data` and `audio_format`.
// See more information here: tensorflow_lite_support/cc/task/audio/core/audio_buffer.h
int input_size = audio_classifier->GetRequiredInputBufferSize();
const std::unique_ptr<AudioBuffer> audio_buffer =
    AudioBuffer::Create(audio_data, input_size, audio_format).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.