Intégrer des classificateurs audio

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

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

Principales fonctionnalités de l'API AudioClassifier

Traitement audio d'entrée, par exemple conversion du codage PCM 16 bits en codage PCM Float et manipulation du tampon en anneau audio.
Paramètres régionaux de la carte d'étiquettes.
Prise en charge du modèle de classification multi-têtes.
Prend en charge la classification à une et plusieurs étiquettes.
Seuil de score pour filtrer les résultats.
Résultats du classement 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 .

Modèles créés par TensorFlow Lite Model Maker pour la classification audio .
Les modèles de classification d'événements audio pré-entraînés sur TensorFlow Hub .
Modèles personnalisés qui répondent aux exigences de compatibilité des modèles .

Exécuter l'inférence en Java

Consultez l’ application de référence Audio Classification pour un exemple d’utilisation 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 des ressources 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.4'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.4.4'
}

É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 bundle d'applications.

É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];

        });
    }
}];

Consultez 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)

Consultez 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();

Consultez 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 lots n'est pas prise en charge ( batch doit être 1).
- pour les modèles multicanaux, les canaux doivent être entrelacés.
Tenseur du score de sortie (kTfLiteFloat32)
- Le tableau [1 x N] avec N représente le numéro de classe.
- Carte(s) d'étiquettes facultative (mais recommandée) en tant qu'AssociatedFile-s de type TENSOR_AXIS_LABELS, contenant une étiquette par ligne. Le premier AssociatedFile (le cas échéant) est utilisé pour remplir le champ 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 ces éléments n'est disponible, seul le champ index des résultats sera renseigné.