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.
- clip audio de taille
Tenseur du score de sortie (kTfLiteFloat32)
- Le tableau
[1 x N]
avecN
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 champdisplay_name
est rempli à partir de l'AssociatedFile (le cas échéant) dont les paramètres régionaux correspondent au champdisplay_names_locale
desAudioClassifierOptions
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 champindex
des résultats sera renseigné.
- Le tableau