Intégrer des classificateurs audio

La classification audio est un cas d'utilisation courant du machine learning types sonores. Par exemple, il peut identifier les espèces d'oiseaux grâce à leurs chants.

L'API AudioClassifier de la bibliothèque de tâches peut être utilisée pour déployer vos fichiers audio personnalisés. des classificateurs ou des classificateurs pré-entraînés dans votre application mobile.

Principales fonctionnalités de l'API AudioClassifier

Traitement audio d'entrée, par exemple convertir l'encodage PCM 16 bits en PCM Encodage float et manipulation du tampon de l'anneau audio.
Paramètres régionaux de la carte de libellés.
Compatibilité avec le modèle de classification à plusieurs têtes.
Prise en charge de la classification à étiquette unique et multi-étiquette.
Seuil de score pour filtrer les résultats.
Top K des résultats de classification.
Liste d'autorisation et liste de blocage d'étiquettes.

Modèles de classificateurs audio compatibles

La compatibilité des modèles suivants avec AudioClassifier est garantie. API.

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

Exécuter une inférence en Java

Consultez le Application de référence pour la classification audio pour voir un exemple avec AudioClassifier dans une application Android.

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

Copiez le fichier de modèle .tflite dans le répertoire d'éléments du module Android. où le modèle sera exécuté. Spécifier que le fichier ne doit pas être compressé 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
    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: Utiliser le 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);

Consultez le Code source et Javadoc pour afficher d'autres options de configuration de AudioClassifier.

Exécuter une inférence sous iOS

Étape 1: Installez 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. Consultez les Guide d'installation de CocoaPods pour obtenir des instructions.

Consultez les Guide CocoaPods pour pour en savoir plus 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: Utiliser le modèle

Swift

// 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)
        }
    }
}

Objective-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 afficher d'autres options de configuration de TFLAudioClassifier.

Exécuter une 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: Utiliser le 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 afficher d'autres options de configuration de AudioClassifier.

Exécuter une 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 afficher d'autres options de configuration de AudioClassifier.

Exigences de compatibilité des modèles

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

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

Tensor d'entrée audio (kTfLiteFloat32)
- clip audio de taille [batch x samples].
- l'inférence par lot n'est pas acceptée (batch doit être défini sur 1).
- Pour les modèles multicanaux, les canaux doivent être entrelacés.
Tensor de score de sortie (kTfLiteFloat32)
- Tableau [1 x N] avec N représentant le numéro de classe.
- des mappages d'étiquettes facultatives (mais recommandés) en tant que AssociatedFiles de type TENSOR_AXIS_LABELS, contenant une étiquette par ligne. Le premier type Le champ AssociatedFile (le cas échéant) est utilisé pour remplir le champ label (nommé ainsi class_name en C++) des résultats. Le champ display_name est rempli à partir de l'élément AssociatedFile (le cas échéant) dont les paramètres régionaux correspondent à Champ display_names_locale de l'AudioClassifierOptions utilisé à date et heure de création ("en" par défaut, c'est-à-dire anglaise). Si aucune de ces options ne correspond disponible, seul le champ index des résultats sera rempli.