Integra clasificadores de audio

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

Se puede usar la API de AudioClassifier de la Biblioteca de tareas para implementar tu audio personalizado clasificadores de texto o los previamente entrenados en tu aplicación.

Funciones clave de la API de AudioClassifier

• Procesamiento de audio de entrada, p.ej., conversión de la codificación PCM de 16 bits a PCM Codificación de número de punto flotante y manipulación del búfer de anillo de audio.

• Etiqueta la configuración regional del mapa.

• Compatibilidad con el modelo de clasificación de varios cabezales

• Compatibilidad con la clasificación de una o varias etiquetas.

• Umbral de puntuación para filtrar los resultados.

• Resultados de clasificación de Top-K.

• Lista de entidades permitidas y listas de bloqueo de etiquetas.

Modelos de clasificador de audio compatibles

Se garantiza la compatibilidad de los siguientes modelos con AudioClassifier en la API de Cloud.

• Modelos creados por TensorFlow Lite Model Maker para la clasificación de audio

• El modelos de clasificación de eventos de audio previamente entrenados en TensorFlow Hub.

• Los modelos personalizados que cumplen con los requisitos de compatibilidad del modelo.

Ejecuta inferencias en Java

Consulta la App de referencia de clasificación de audio Consulta un ejemplo con AudioClassifier en una app para Android.

Paso 1: Importa la dependencia de Gradle y otros parámetros de configuración

Copia el archivo de modelo .tflite en el directorio de recursos del módulo de Android. en la que se ejecutará el modelo. Especificar que el archivo no debe comprimirse agrega la biblioteca de 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
    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: Usa 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);

Consulta la código fuente y javadoc si quieres obtener más opciones para configurar AudioClassifier.

Ejecuta la inferencia en iOS

Paso 1: Instala las dependencias

La Biblioteca de tareas admite la instalación con CocoaPods. Asegúrate de que CocoaPods esté instalado en tu sistema. Consulta la Guía de instalación de CocoaPods para obtener instrucciones.

Consulta la Guía de CocoaPods para detalles sobre cómo agregar Pods a un proyecto Xcode.

Agrega el Pod TensorFlowLiteTaskAudio en el Podfile.

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

Asegúrate de que el modelo .tflite que usarás para la inferencia esté presente en tu paquete de aplicación.

Paso 2: Usa el modelo

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

        });
    }
}];

Consulta la código fuente si quieres obtener más opciones para configurar TFLAudioClassifier.

Ejecuta la inferencia en Python

Paso 1: Instala el paquete pip

pip install tflite-support

• Linux: Ejecuta sudo apt-get update && apt-get install libportaudio2.
• Mac y Windows: PortAudio se instala automáticamente al instalar la aplicación Paquete pip de tflite-support.

Paso 2: Usa 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)

Consulta la código fuente si quieres obtener más opciones para configurar AudioClassifier.

Ejecuta inferencias 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();

Consulta la código fuente si quieres obtener más opciones para configurar AudioClassifier.

Requisitos de compatibilidad del modelo

La API de AudioClassifier espera un modelo TFLite con Metadatos del modelo de TFLite. Consulta ejemplos de crear metadatos para clasificadores de audio con el API de TensorFlow Lite Metadata Writer

Los modelos clasificadores de audio compatibles deben cumplir con los siguientes requisitos:

• Tensor de audio de entrada (kTfLiteFloat32)

  • clip de audio de un tamaño de [batch x samples].
  • no se admite la inferencia por lotes (se requiere que batch sea 1).
  • Para los modelos multicanal, los canales deben estar intercalados.

• Tensor de puntuación de salida (kTfLiteFloat32)

  • El array [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 contiene una etiqueta por línea. El primer tipo El elemento AssociatedFile (si existe) se usa para completar el campo label (llamado class_name en C++) de los resultados. Se completó el campo display_name del AssociatedFile (si corresponde) cuya configuración regional coincida con Campo display_names_locale de la AudioClassifierOptions utilizada en “en” (“en”) de forma predeterminada, es decir, en inglés. Si ninguno de estos es disponible, solo se completará el campo index de los resultados.