Integra clasificadores de audio

La clasificación de audio es un caso de uso común del aprendizaje automático para clasificar los tipos de sonido. Por ejemplo, puede identificar las especies de aves por sus cantos.

La API AudioClassifier de la biblioteca de tareas se puede utilizar para implementar sus clasificadores de audio personalizados o previamente entrenados en su aplicación móvil.

Características clave de la API AudioClassifier

  • Procesamiento de audio de entrada, por ejemplo, conversión de codificación PCM de 16 bits a codificación PCM flotante y manipulación del búfer en anillo de audio.

  • Localización del mapa de etiquetas.

  • Compatible con el modelo de clasificación de cabezales múltiples.

  • Admite clasificación de etiqueta única y de etiqueta múltiple.

  • Umbral de puntuación para filtrar resultados.

  • Resultados de la clasificación top-k.

  • Etiquetar lista permitida y lista denegada.

Modelos de clasificador de audio compatibles

Se garantiza que los siguientes modelos serán compatibles con la API AudioClassifier .

Ejecutar inferencia en Java

Consulte la aplicación de referencia de Clasificación de audio para ver un ejemplo de uso de AudioClassifier en una aplicación de Android.

Paso 1: importar la dependencia de Gradle y otras configuraciones

Copie el archivo del modelo .tflite en el directorio de activos del módulo de Android donde se ejecutará el modelo. Especifique que el archivo no debe comprimirse y agregue la biblioteca TensorFlow Lite al archivo build.gradle del módulo:

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'
}

Paso 2: usar el modelo

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

Consulte el código fuente y javadoc para obtener más opciones para configurar AudioClassifier .

Ejecutar inferencia en iOS

Paso 1: instalar las dependencias

La biblioteca de tareas admite la instalación mediante CocoaPods. Asegúrese de que CocoaPods esté instalado en su sistema. Consulte la guía de instalación de CocoaPods para obtener instrucciones.

Consulte la guía CocoaPods para obtener detalles sobre cómo agregar pods a un proyecto Xcode.

Agregue el pod TensorFlowLiteTaskAudio en el Podfile.

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

Asegúrese de que el modelo .tflite que utilizará para la inferencia esté presente en el paquete de su aplicación.

Paso 2: usar el modelo

Rápido

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

C objetivo

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

        });
    }
}];

Consulte el código fuente para obtener más opciones para configurar TFLAudioClassifier .

Ejecutar inferencia en Python

Paso 1: instale el paquete pip

pip install tflite-support
  • Linux: ejecute sudo apt-get update && apt-get install libportaudio2
  • Mac y Windows: PortAudio se instala automáticamente al instalar el paquete pip tflite-support .

Paso 2: usar el modelo

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

Consulte el código fuente para obtener más opciones para configurar AudioClassifier .

Ejecutar inferencia 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();

Consulte el código fuente para obtener más opciones para configurar AudioClassifier .

Requisitos de compatibilidad del modelo

La API AudioClassifier espera un modelo TFLite con metadatos del modelo TFLite obligatorios. Vea ejemplos de creación de metadatos para clasificadores de audio utilizando la API de escritura de metadatos de TensorFlow Lite .

Los modelos de clasificador de audio compatibles deben cumplir los siguientes requisitos:

  • Tensor de audio de entrada (kTfLiteFloat32)

    • clip de audio de tamaño [batch x samples] .
    • No se admite la inferencia por lotes (se requiere que batch sea 1).
    • para los modelos multicanal, los canales deben estar entrelazados.
  • Tensor de puntuación de salida (kTfLiteFloat32)

    • La matriz [1 x N] con N representa el número de clase.
    • Mapas de etiquetas opcionales (pero recomendados) como AssociatedFile-s con tipo TENSOR_AXIS_LABELS, que contienen una etiqueta por línea. El primer AssociatedFile (si lo hay) se utiliza para completar el campo label (denominado class_name en C++) de los resultados. El campo display_name se completa desde AssociatedFile (si lo hay) cuya configuración regional coincide con el campo display_names_locale de AudioClassifierOptions utilizado en el momento de la creación ("en" de forma predeterminada, es decir, inglés). Si ninguno de estos está disponible, solo se completará el campo index de los resultados.