La classificazione audio è un caso d'uso comune del Machine Learning per classificare i tipi di suono. Ad esempio, può identificare le specie di uccelli dal loro canto.
L'API AudioClassifier
della libreria attività può essere utilizzata per distribuire i classificatori audio personalizzati o preaddestrati nella tua app mobile.
Funzionalità principali dell'API AudioClassifier
Elaborazione dell'audio in ingresso, ad esempio conversione della codifica PCM a 16 bit in codifica PCM Float e manipolazione del buffer dell'anello audio.
Etichetta locale della mappa.
Supporto del modello di classificazione multi-testa.
Supporta la classificazione sia a etichetta singola che multietichetta.
Soglia del punteggio per filtrare i risultati.
Risultati della classifica Topk.
Etichetta lista consentita e lista negata.
Modelli di classificazione audio supportati
È garantita la compatibilità dei seguenti modelli con l'API AudioClassifier
.
Modelli creati da TensorFlow Lite Model Maker per la classificazione audio .
I modelli di classificazione degli eventi audio preaddestrati su TensorFlow Hub .
Modelli personalizzati che soddisfano i requisiti di compatibilità del modello .
Esegui l'inferenza in Java
Consulta l' app di riferimento per la classificazione audio per un esempio di utilizzo di AudioClassifier
in un'app Android.
Passaggio 1: importa la dipendenza Gradle e altre impostazioni
Copia il file del modello .tflite
nella directory asset del modulo Android in cui verrà eseguito il modello. Specifica che il file non deve essere compresso e aggiungi la libreria TensorFlow Lite al file build.gradle
del modulo:
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'
}
Passaggio 2: utilizzo del modello
// 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);
Consulta il codice sorgente e javadoc per ulteriori opzioni per configurare AudioClassifier
.
Esegui l'inferenza in iOS
Passaggio 1: installa le dipendenze
La libreria attività supporta l'installazione utilizzando CocoaPods. Assicurati che CocoaPods sia installato sul tuo sistema. Per istruzioni, consultare la guida all'installazione di CocoaPods .
Consulta la guida CocoaPods per i dettagli sull'aggiunta di pod a un progetto Xcode.
Aggiungi il pod TensorFlowLiteTaskAudio
nel Podfile.
target 'MyAppWithTaskAPI' do
use_frameworks!
pod 'TensorFlowLiteTaskAudio'
end
Assicurati che il modello .tflite
che utilizzerai per l'inferenza sia presente nel pacchetto dell'app.
Passaggio 2: utilizzo del modello
Veloce
// 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)
}
}
}
Obiettivo 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];
});
}
}];
Consulta il codice sorgente per ulteriori opzioni per configurare TFLAudioClassifier
.
Esegui l'inferenza in Python
Passaggio 1: installa il pacchetto pip
pip install tflite-support
- Linux: esegui
sudo apt-get update && apt-get install libportaudio2
- Mac e Windows: PortAudio viene installato automaticamente durante l'installazione del pacchetto pip
tflite-support
.
Passaggio 2: utilizzo del modello
# 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)
Consulta il codice sorgente per ulteriori opzioni per configurare AudioClassifier
.
Esegui l'inferenza in 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();
Consulta il codice sorgente per ulteriori opzioni per configurare AudioClassifier
.
Requisiti di compatibilità del modello
L'API AudioClassifier
prevede un modello TFLite con metadati del modello TFLite obbligatori. Guarda esempi di creazione di metadati per classificatori audio utilizzando l' API TensorFlow Lite Metadata Writer .
I modelli di classificatore audio compatibili devono soddisfare i seguenti requisiti:
Tensore audio in ingresso (kTfLiteFloat32)
- clip audio di dimensioni
[batch x samples]
. - l'inferenza batch non è supportata (
batch
deve essere 1). - per i modelli multicanale, i canali devono essere interlacciati.
- clip audio di dimensioni
Tensore del punteggio di output (kTfLiteFloat32)
- L'array
[1 x N]
conN
rappresenta il numero della classe. - mappe di etichette facoltative (ma consigliate) come AssociatedFile con tipo TENSOR_AXIS_LABELS, contenenti un'etichetta per riga. Il primo AssociatedFile (se presente) viene utilizzato per riempire il campo
label
(denominatoclass_name
in C++) dei risultati. Il campodisplay_name
viene compilato dall'AssociadFile (se presente) la cui locale corrisponde al campodisplay_names_locale
diAudioClassifierOptions
utilizzato al momento della creazione ("en" per impostazione predefinita, ovvero inglese). Se nessuno di questi è disponibile, verrà compilato solo il campoindex
dei risultati.
- L'array